From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753818AbeB0Odh (ORCPT ); Tue, 27 Feb 2018 09:33:37 -0500 Received: from smtp.domeneshop.no ([194.63.252.55]:44811 "EHLO smtp.domeneshop.no" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753743AbeB0Odf (ORCPT ); Tue, 27 Feb 2018 09:33:35 -0500 Subject: Re: [PATCH] drm/tinydrm: Allocate dummy SPI RX buffer if needed To: David Lechner , dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org References: <1519082461-32405-1-git-send-email-david@lechnology.com> From: =?UTF-8?Q?Noralf_Tr=c3=b8nnes?= Message-ID: <470d5309-3414-74b8-1329-577037528a8e@tronnes.org> Date: Tue, 27 Feb 2018 15:33:28 +0100 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Thunderbird/52.6.0 MIME-Version: 1.0 In-Reply-To: <1519082461-32405-1-git-send-email-david@lechnology.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Den 20.02.2018 00.21, skrev David Lechner: > This adds a new feature to allocate a dummy RX buffer for SPI controllers > that require an RX buffer even when not receiving. If an RX buffer is not > supplied, the SPI controller will reallocate a new buffer on each > transfer. > > On systems with limited memory (e.g. 64MB and CONFIG_SWAP=n), this > reallocation will occasionally fail, which causes the display to stop > working. By allocating this buffer once and reusing it, we can prevent > this problem. > > This patch also introduces some helper functions for calculating the > size of this buffer, so these functions are re-used where possible > (e.g. in mipi_dbi_init()). > > Cc: Noralf Trønnes > Suggested-by: Noralf Trønnes > Signed-off-by: David Lechner > --- > > This is a follow up from the mail thread "tinydrm: page allocation failure" [1]. > I actually got an allocation failure a few times even when I had swap enabled, > so I think this change is needed. > > [1]: https://www.mail-archive.com/dri-devel@lists.freedesktop.org/msg203657.html I was hoping that we could avoid touching drivers with this change. In the current situation it would be enough to allocate a buffer the size of what tinydrm_spi_max_transfer_size() returns, because that's the maximun transfers length used in tinydrm_spi_transfer(). However Meghana is trying to remove the transfer buffer splitting [1], so I think we should wait and see the outcome of that first. If in the end we do send the entire buffer, maybe we can defer allocating the rx buffer until the first time it is used so we can know the buffer size without asking the drivers. If we add this and set it in mipi_dbi_init():  struct mipi_dbi {     u16 *tx_buf; +    size_t tx_len;  }; We can now allocate the rx buffer in mipi_dbi_typec3_command(): static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd,                    u8 *par, size_t num) { +    if (!mipi->rx_buf && spi->controller->flags & SPI_CONTROLLER_MUST_RX) { +        mipi->rx_buf = devm_kmalloc(dev, mipi->tx_len, GFP_KERNEL); +        if (!mipi->rx_buf) +            return -ENOMEM; +    } } Option 1 has it's own transfer buffer and size: static int mipi_dbi_typec1_command(struct mipi_dbi *mipi, u8 cmd,                    u8 *parameters, size_t num) { +        mipi->rx_buf = devm_kmalloc(dev, mipi->tx_buf9_len, GFP_KERNEL); } Hopefully before summer I have switched to vmalloc backing for the framebuffers (which means we can PRIME import from GPU's with shmem buffers). This means that we can just use vmalloc transfer buffers as well. The SPI core can dma map vmalloc buffers (spi_map_buf), it just makes an SG table with an entry per PAGE. [1]: [PATCH v2 0/2] Chunk splitting of spi transfers https://lists.freedesktop.org/archives/dri-devel/2018-February/167181.html Noralf. > drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c | 9 ++++++++- > drivers/gpu/drm/tinydrm/ili9225.c | 8 +++++--- > drivers/gpu/drm/tinydrm/mi0283qt.c | 3 ++- > drivers/gpu/drm/tinydrm/mipi-dbi.c | 20 ++++++++++++++++---- > drivers/gpu/drm/tinydrm/st7586.c | 13 +++++++++++-- > drivers/gpu/drm/tinydrm/st7735r.c | 3 ++- > include/drm/tinydrm/mipi-dbi.h | 16 +++++++++++++++- > include/drm/tinydrm/tinydrm-helpers.h | 2 +- > 8 files changed, 60 insertions(+), 14 deletions(-) > > diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c b/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c > index bf96072..f5c175e 100644 > --- a/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c > +++ b/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c > @@ -434,6 +434,7 @@ EXPORT_SYMBOL(_tinydrm_dbg_spi_message); > * @header: Optional header transfer > * @bpw: Bits per word > * @buf: Buffer to transfer > + * @rx_buf: Optional dummy buffer > * @len: Buffer length > * > * This SPI transfer helper breaks up the transfer of @buf into chunks which > @@ -442,16 +443,22 @@ EXPORT_SYMBOL(_tinydrm_dbg_spi_message); > * does a 8-bit transfer. > * If @header is set, it is prepended to each SPI message. > * > + * Some SPI controllers need an RX buffer even though we are not receiving > + * anything useful. @rx_buf can be provided so that the SPI controller does not > + * have to reallocate this buffer on each transfer. This is useful for large > + * transfers, e.g. when updating the GRAM. > + * > * Returns: > * Zero on success, negative error code on failure. > */ > int tinydrm_spi_transfer(struct spi_device *spi, u32 speed_hz, > struct spi_transfer *header, u8 bpw, const void *buf, > - size_t len) > + void *rx_buf, size_t len) > { > struct spi_transfer tr = { > .bits_per_word = bpw, > .speed_hz = speed_hz, > + .rx_buf = rx_buf, > }; > struct spi_message m; > u16 *swap_buf = NULL; > diff --git a/drivers/gpu/drm/tinydrm/ili9225.c b/drivers/gpu/drm/tinydrm/ili9225.c > index a075950..c15f49a 100644 > --- a/drivers/gpu/drm/tinydrm/ili9225.c > +++ b/drivers/gpu/drm/tinydrm/ili9225.c > @@ -300,7 +300,7 @@ static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 cmd, u8 *par, > > gpiod_set_value_cansleep(mipi->dc, 0); > speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1); > - ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1); > + ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, NULL, 1); > if (ret || !num) > return ret; > > @@ -310,7 +310,8 @@ static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 cmd, u8 *par, > gpiod_set_value_cansleep(mipi->dc, 1); > speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num); > > - return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, num); > + return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, mipi->rx_buf, > + num); > } > > static const u32 ili9225_formats[] = { > @@ -400,6 +401,7 @@ MODULE_DEVICE_TABLE(spi, ili9225_id); > > static int ili9225_probe(struct spi_device *spi) > { > + size_t bufsize = mipi_dbi_max_buf_size(&ili9225_mode); > struct device *dev = &spi->dev; > struct mipi_dbi *mipi; > struct gpio_desc *rs; > @@ -424,7 +426,7 @@ static int ili9225_probe(struct spi_device *spi) > > device_property_read_u32(dev, "rotation", &rotation); > > - ret = mipi_dbi_spi_init(spi, mipi, rs); > + ret = mipi_dbi_spi_init(spi, mipi, rs, bufsize); > if (ret) > return ret; > > diff --git a/drivers/gpu/drm/tinydrm/mi0283qt.c b/drivers/gpu/drm/tinydrm/mi0283qt.c > index 79cb5af..c3fa682 100644 > --- a/drivers/gpu/drm/tinydrm/mi0283qt.c > +++ b/drivers/gpu/drm/tinydrm/mi0283qt.c > @@ -169,6 +169,7 @@ MODULE_DEVICE_TABLE(spi, mi0283qt_id); > > static int mi0283qt_probe(struct spi_device *spi) > { > + size_t bufsize = mipi_dbi_max_buf_size(&mi0283qt_mode); > struct device *dev = &spi->dev; > struct mipi_dbi *mipi; > struct gpio_desc *dc; > @@ -201,7 +202,7 @@ static int mi0283qt_probe(struct spi_device *spi) > > device_property_read_u32(dev, "rotation", &rotation); > > - ret = mipi_dbi_spi_init(spi, mipi, dc); > + ret = mipi_dbi_spi_init(spi, mipi, dc, bufsize); > if (ret) > return ret; > > diff --git a/drivers/gpu/drm/tinydrm/mipi-dbi.c b/drivers/gpu/drm/tinydrm/mipi-dbi.c > index 75dd65c..16bee06 100644 > --- a/drivers/gpu/drm/tinydrm/mipi-dbi.c > +++ b/drivers/gpu/drm/tinydrm/mipi-dbi.c > @@ -364,7 +364,7 @@ int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi, > struct drm_driver *driver, > const struct drm_display_mode *mode, unsigned int rotation) > { > - size_t bufsize = mode->vdisplay * mode->hdisplay * sizeof(u16); > + size_t bufsize = mipi_dbi_max_buf_size(mode); > struct tinydrm_device *tdev = &mipi->tinydrm; > int ret; > > @@ -848,7 +848,7 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, > > gpiod_set_value_cansleep(mipi->dc, 0); > speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1); > - ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1); > + ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, NULL, 1); > if (ret || !num) > return ret; > > @@ -858,7 +858,8 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, > gpiod_set_value_cansleep(mipi->dc, 1); > speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num); > > - return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, num); > + return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, mipi->rx_buf, > + num); > } > > /** > @@ -866,6 +867,7 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, > * @spi: SPI device > * @mipi: &mipi_dbi structure to initialize > * @dc: D/C gpio (optional) > + * @max_size: Maximum TX buffer size needed by the caller > * > * This function sets &mipi_dbi->command, enables &mipi->read_commands for the > * usual read commands. It should be followed by a call to mipi_dbi_init() or > @@ -884,7 +886,7 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, > * Zero on success, negative error code on failure. > */ > int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi, > - struct gpio_desc *dc) > + struct gpio_desc *dc, size_t max_size) > { > size_t tx_size = tinydrm_spi_max_transfer_size(spi, 0); > struct device *dev = &spi->dev; > @@ -930,6 +932,16 @@ int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi, > return -ENOMEM; > } > > + /* > + * Allocate a dummy RX buffer if needed, otherwise the SPI controller > + * will have to reallocate a new buffer on each transfer. > + */ > + if (spi->controller->flags & SPI_CONTROLLER_MUST_RX) { > + mipi->rx_buf = devm_kmalloc(dev, max_size, GFP_KERNEL); > + if (!mipi->rx_buf) > + return -ENOMEM; > + } > + > DRM_DEBUG_DRIVER("SPI speed: %uMHz\n", spi->max_speed_hz / 1000000); > > return 0; > diff --git a/drivers/gpu/drm/tinydrm/st7586.c b/drivers/gpu/drm/tinydrm/st7586.c > index a6396ef..bb0d55d 100644 > --- a/drivers/gpu/drm/tinydrm/st7586.c > +++ b/drivers/gpu/drm/tinydrm/st7586.c > @@ -42,6 +42,14 @@ > #define ST7586_DISP_CTRL_MX BIT(6) > #define ST7586_DISP_CTRL_MY BIT(7) > > +static inline size_t st7586_buf_max_size(const struct drm_display_mode *mode) > +{ > + size_t width = (mode->hdisplay + 2) / 3; /* 3 pixels per byte */ > + size_t height = mode->vdisplay; > + > + return width * height; > +} > + > /* > * The ST7586 controller has an unusual pixel format where 2bpp grayscale is > * packed 3 pixels per byte with the first two pixels using 3 bits and the 3rd > @@ -263,7 +271,7 @@ static int st7586_init(struct device *dev, struct mipi_dbi *mipi, > struct drm_driver *driver, const struct drm_display_mode *mode, > unsigned int rotation) > { > - size_t bufsize = (mode->vdisplay + 2) / 3 * mode->hdisplay; > + size_t bufsize = st7586_buf_max_size(mode); > struct tinydrm_device *tdev = &mipi->tinydrm; > int ret; > > @@ -337,6 +345,7 @@ MODULE_DEVICE_TABLE(spi, st7586_id); > > static int st7586_probe(struct spi_device *spi) > { > + size_t bufsize = st7586_buf_max_size(&st7586_mode); > struct device *dev = &spi->dev; > struct mipi_dbi *mipi; > struct gpio_desc *a0; > @@ -361,7 +370,7 @@ static int st7586_probe(struct spi_device *spi) > > device_property_read_u32(dev, "rotation", &rotation); > > - ret = mipi_dbi_spi_init(spi, mipi, a0); > + ret = mipi_dbi_spi_init(spi, mipi, a0, bufsize); > if (ret) > return ret; > > diff --git a/drivers/gpu/drm/tinydrm/st7735r.c b/drivers/gpu/drm/tinydrm/st7735r.c > index 08b4fb1..c047bac 100644 > --- a/drivers/gpu/drm/tinydrm/st7735r.c > +++ b/drivers/gpu/drm/tinydrm/st7735r.c > @@ -141,6 +141,7 @@ MODULE_DEVICE_TABLE(spi, st7735r_id); > > static int st7735r_probe(struct spi_device *spi) > { > + size_t bufsize = mipi_dbi_max_buf_size(&jd_t18003_t01_mode); > struct device *dev = &spi->dev; > struct mipi_dbi *mipi; > struct gpio_desc *dc; > @@ -169,7 +170,7 @@ static int st7735r_probe(struct spi_device *spi) > > device_property_read_u32(dev, "rotation", &rotation); > > - ret = mipi_dbi_spi_init(spi, mipi, dc); > + ret = mipi_dbi_spi_init(spi, mipi, dc, bufsize); > if (ret) > return ret; > > diff --git a/include/drm/tinydrm/mipi-dbi.h b/include/drm/tinydrm/mipi-dbi.h > index 44e824a..deee862 100644 > --- a/include/drm/tinydrm/mipi-dbi.h > +++ b/include/drm/tinydrm/mipi-dbi.h > @@ -31,6 +31,7 @@ struct regulator; > * @tx_buf: Buffer used for transfer (copy clip rect area) > * @tx_buf9: Buffer used for Option 1 9-bit conversion > * @tx_buf9_len: Size of tx_buf9. > + * @rx_buf: Optional dummy RX buffer. > * @swap_bytes: Swap bytes in buffer before transfer > * @reset: Optional reset gpio > * @rotation: initial rotation in degrees Counter Clock Wise > @@ -48,6 +49,7 @@ struct mipi_dbi { > u16 *tx_buf; > void *tx_buf9; > size_t tx_buf9_len; > + void *rx_buf; > bool swap_bytes; > struct gpio_desc *reset; > unsigned int rotation; > @@ -62,7 +64,7 @@ mipi_dbi_from_tinydrm(struct tinydrm_device *tdev) > } > > int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi, > - struct gpio_desc *dc); > + struct gpio_desc *dc, size_t max_size); > int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi, > const struct drm_simple_display_pipe_funcs *pipe_funcs, > struct drm_driver *driver, > @@ -79,6 +81,18 @@ int mipi_dbi_command_read(struct mipi_dbi *mipi, u8 cmd, u8 *val); > int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len); > int mipi_dbi_buf_copy(void *dst, struct drm_framebuffer *fb, > struct drm_clip_rect *clip, bool swap); > + > +/** > + * mipi_dbi_max_buf_size - Get the maximum required framebuffer memory size > + * @mode: The display mode data > + * > + * Computes the maximum buffer size needed for a 2 byte per pixel display. > + */ > +static inline size_t mipi_dbi_max_buf_size(const struct drm_display_mode *mode) > +{ > + return mode->hdisplay * mode->vdisplay * sizeof(u16); > +} > + > /** > * mipi_dbi_command - MIPI DCS command with optional parameter(s) > * @mipi: MIPI structure > diff --git a/include/drm/tinydrm/tinydrm-helpers.h b/include/drm/tinydrm/tinydrm-helpers.h > index d554ded..e5e8f59 100644 > --- a/include/drm/tinydrm/tinydrm-helpers.h > +++ b/include/drm/tinydrm/tinydrm-helpers.h > @@ -54,7 +54,7 @@ size_t tinydrm_spi_max_transfer_size(struct spi_device *spi, size_t max_len); > bool tinydrm_spi_bpw_supported(struct spi_device *spi, u8 bpw); > int tinydrm_spi_transfer(struct spi_device *spi, u32 speed_hz, > struct spi_transfer *header, u8 bpw, const void *buf, > - size_t len); > + void *rx_buf, size_t len); > void _tinydrm_dbg_spi_message(struct spi_device *spi, struct spi_message *m); > > #ifdef DEBUG From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?Q?Noralf_Tr=c3=b8nnes?= Subject: Re: [PATCH] drm/tinydrm: Allocate dummy SPI RX buffer if needed Date: Tue, 27 Feb 2018 15:33:28 +0100 Message-ID: <470d5309-3414-74b8-1329-577037528a8e@tronnes.org> References: <1519082461-32405-1-git-send-email-david@lechnology.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from smtp.domeneshop.no (smtp.domeneshop.no [IPv6:2a01:5b40:0:3005::1]) by gabe.freedesktop.org (Postfix) with ESMTPS id D137C6E6CE for ; Tue, 27 Feb 2018 14:33:34 +0000 (UTC) In-Reply-To: <1519082461-32405-1-git-send-email-david@lechnology.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: David Lechner , dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org CkRlbiAyMC4wMi4yMDE4IDAwLjIxLCBza3JldiBEYXZpZCBMZWNobmVyOgo+IFRoaXMgYWRkcyBh IG5ldyBmZWF0dXJlIHRvIGFsbG9jYXRlIGEgZHVtbXkgUlggYnVmZmVyIGZvciBTUEkgY29udHJv bGxlcnMKPiB0aGF0IHJlcXVpcmUgYW4gUlggYnVmZmVyIGV2ZW4gd2hlbiBub3QgcmVjZWl2aW5n LiBJZiBhbiBSWCBidWZmZXIgaXMgbm90Cj4gc3VwcGxpZWQsIHRoZSBTUEkgY29udHJvbGxlciB3 aWxsIHJlYWxsb2NhdGUgYSBuZXcgYnVmZmVyIG9uIGVhY2gKPiB0cmFuc2Zlci4KPgo+IE9uIHN5 c3RlbXMgd2l0aCBsaW1pdGVkIG1lbW9yeSAoZS5nLiA2NE1CIGFuZCBDT05GSUdfU1dBUD1uKSwg dGhpcwo+IHJlYWxsb2NhdGlvbiB3aWxsIG9jY2FzaW9uYWxseSBmYWlsLCB3aGljaCBjYXVzZXMg dGhlIGRpc3BsYXkgdG8gc3RvcAo+IHdvcmtpbmcuIEJ5IGFsbG9jYXRpbmcgdGhpcyBidWZmZXIg b25jZSBhbmQgcmV1c2luZyBpdCwgd2UgY2FuIHByZXZlbnQKPiB0aGlzIHByb2JsZW0uCj4KPiBU aGlzIHBhdGNoIGFsc28gaW50cm9kdWNlcyBzb21lIGhlbHBlciBmdW5jdGlvbnMgZm9yIGNhbGN1 bGF0aW5nIHRoZQo+IHNpemUgb2YgdGhpcyBidWZmZXIsIHNvIHRoZXNlIGZ1bmN0aW9ucyBhcmUg cmUtdXNlZCB3aGVyZSBwb3NzaWJsZQo+IChlLmcuIGluIG1pcGlfZGJpX2luaXQoKSkuCj4KPiBD YzogTm9yYWxmIFRyw7hubmVzIDxub3JhbGZAdHJvbm5lcy5vcmc+Cj4gU3VnZ2VzdGVkLWJ5OiBO b3JhbGYgVHLDuG5uZXMgPG5vcmFsZkB0cm9ubmVzLm9yZz4KPiBTaWduZWQtb2ZmLWJ5OiBEYXZp ZCBMZWNobmVyIDxkYXZpZEBsZWNobm9sb2d5LmNvbT4KPiAtLS0KPgo+IFRoaXMgaXMgYSBmb2xs b3cgdXAgZnJvbSB0aGUgbWFpbCB0aHJlYWQgInRpbnlkcm06IHBhZ2UgYWxsb2NhdGlvbiBmYWls dXJlIiBbMV0uCj4gSSBhY3R1YWxseSBnb3QgYW4gYWxsb2NhdGlvbiBmYWlsdXJlIGEgZmV3IHRp bWVzIGV2ZW4gd2hlbiBJIGhhZCBzd2FwIGVuYWJsZWQsCj4gc28gSSB0aGluayB0aGlzIGNoYW5n ZSBpcyBuZWVkZWQuCj4KPiBbMV06IGh0dHBzOi8vd3d3Lm1haWwtYXJjaGl2ZS5jb20vZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZy9tc2cyMDM2NTcuaHRtbAoKSSB3YXMgaG9waW5nIHRo YXQgd2UgY291bGQgYXZvaWQgdG91Y2hpbmcgZHJpdmVycyB3aXRoIHRoaXMgY2hhbmdlLgoKSW4g dGhlIGN1cnJlbnQgc2l0dWF0aW9uIGl0IHdvdWxkIGJlIGVub3VnaCB0byBhbGxvY2F0ZSBhIGJ1 ZmZlciB0aGUgc2l6ZQpvZiB3aGF0IHRpbnlkcm1fc3BpX21heF90cmFuc2Zlcl9zaXplKCkgcmV0 dXJucywgYmVjYXVzZSB0aGF0J3MgdGhlCm1heGltdW4gdHJhbnNmZXJzIGxlbmd0aCB1c2VkIGlu IHRpbnlkcm1fc3BpX3RyYW5zZmVyKCkuCgpIb3dldmVyIE1lZ2hhbmEgaXMgdHJ5aW5nIHRvIHJl bW92ZSB0aGUgdHJhbnNmZXIgYnVmZmVyIHNwbGl0dGluZyBbMV0sCnNvIEkgdGhpbmsgd2Ugc2hv dWxkIHdhaXQgYW5kIHNlZSB0aGUgb3V0Y29tZSBvZiB0aGF0IGZpcnN0LgoKSWYgaW4gdGhlIGVu ZCB3ZSBkbyBzZW5kIHRoZSBlbnRpcmUgYnVmZmVyLCBtYXliZSB3ZSBjYW4gZGVmZXIKYWxsb2Nh dGluZyB0aGUgcnggYnVmZmVyIHVudGlsIHRoZSBmaXJzdCB0aW1lIGl0IGlzIHVzZWQgc28gd2Ug Y2FuCmtub3cgdGhlIGJ1ZmZlciBzaXplIHdpdGhvdXQgYXNraW5nIHRoZSBkcml2ZXJzLgoKSWYg d2UgYWRkIHRoaXMgYW5kIHNldCBpdCBpbiBtaXBpX2RiaV9pbml0KCk6CgogwqBzdHJ1Y3QgbWlw aV9kYmkgewogwqDCoMKgIHUxNiAqdHhfYnVmOworwqDCoMKgIHNpemVfdCB0eF9sZW47CiDCoH07 CgpXZSBjYW4gbm93IGFsbG9jYXRlIHRoZSByeCBidWZmZXIgaW4gbWlwaV9kYmlfdHlwZWMzX2Nv bW1hbmQoKToKCnN0YXRpYyBpbnQgbWlwaV9kYmlfdHlwZWMzX2NvbW1hbmQoc3RydWN0IG1pcGlf ZGJpICptaXBpLCB1OCBjbWQsCiDCoMKgwqAgwqDCoMKgIMKgwqDCoCDCoMKgwqAgwqDCoCB1OCAq cGFyLCBzaXplX3QgbnVtKQp7CgorwqDCoMKgIGlmICghbWlwaS0+cnhfYnVmICYmIHNwaS0+Y29u dHJvbGxlci0+ZmxhZ3MgJiBTUElfQ09OVFJPTExFUl9NVVNUX1JYKSB7CivCoMKgwqAgwqDCoMKg IG1pcGktPnJ4X2J1ZiA9IGRldm1fa21hbGxvYyhkZXYsIG1pcGktPnR4X2xlbiwgR0ZQX0tFUk5F TCk7CivCoMKgwqAgwqDCoMKgIGlmICghbWlwaS0+cnhfYnVmKQorwqDCoMKgIMKgwqDCoCDCoMKg wqAgcmV0dXJuIC1FTk9NRU07CivCoMKgwqAgfQoKfQoKT3B0aW9uIDEgaGFzIGl0J3Mgb3duIHRy YW5zZmVyIGJ1ZmZlciBhbmQgc2l6ZToKCnN0YXRpYyBpbnQgbWlwaV9kYmlfdHlwZWMxX2NvbW1h bmQoc3RydWN0IG1pcGlfZGJpICptaXBpLCB1OCBjbWQsCiDCoMKgwqAgwqDCoMKgIMKgwqDCoCDC oMKgwqAgwqDCoCB1OCAqcGFyYW1ldGVycywgc2l6ZV90IG51bSkKewoKK8KgwqDCoCDCoMKgwqAg bWlwaS0+cnhfYnVmID0gZGV2bV9rbWFsbG9jKGRldiwgbWlwaS0+dHhfYnVmOV9sZW4sIEdGUF9L RVJORUwpOwoKfQoKCkhvcGVmdWxseSBiZWZvcmUgc3VtbWVyIEkgaGF2ZSBzd2l0Y2hlZCB0byB2 bWFsbG9jIGJhY2tpbmcgZm9yIHRoZQpmcmFtZWJ1ZmZlcnMgKHdoaWNoIG1lYW5zIHdlIGNhbiBQ UklNRSBpbXBvcnQgZnJvbSBHUFUncyB3aXRoIHNobWVtCmJ1ZmZlcnMpLiBUaGlzIG1lYW5zIHRo YXQgd2UgY2FuIGp1c3QgdXNlIHZtYWxsb2MgdHJhbnNmZXIgYnVmZmVycyBhcwp3ZWxsLiBUaGUg U1BJIGNvcmUgY2FuIGRtYSBtYXAgdm1hbGxvYyBidWZmZXJzIChzcGlfbWFwX2J1ZiksIGl0IGp1 c3QKbWFrZXMgYW4gU0cgdGFibGUgd2l0aCBhbiBlbnRyeSBwZXIgUEFHRS4KClsxXTogW1BBVENI IHYyIDAvMl0gQ2h1bmsgc3BsaXR0aW5nIG9mIHNwaSB0cmFuc2ZlcnMKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvYXJjaGl2ZXMvZHJpLWRldmVsLzIwMTgtRmVicnVhcnkvMTY3MTgxLmh0 bWwKCk5vcmFsZi4KCj4gICBkcml2ZXJzL2dwdS9kcm0vdGlueWRybS9jb3JlL3Rpbnlkcm0taGVs cGVycy5jIHwgIDkgKysrKysrKystCj4gICBkcml2ZXJzL2dwdS9kcm0vdGlueWRybS9pbGk5MjI1 LmMgICAgICAgICAgICAgIHwgIDggKysrKystLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS90aW55ZHJt L21pMDI4M3F0LmMgICAgICAgICAgICAgfCAgMyArKy0KPiAgIGRyaXZlcnMvZ3B1L2RybS90aW55 ZHJtL21pcGktZGJpLmMgICAgICAgICAgICAgfCAyMCArKysrKysrKysrKysrKysrLS0tLQo+ICAg ZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NTg2LmMgICAgICAgICAgICAgICB8IDEzICsrKysr KysrKysrLS0KPiAgIGRyaXZlcnMvZ3B1L2RybS90aW55ZHJtL3N0NzczNXIuYyAgICAgICAgICAg ICAgfCAgMyArKy0KPiAgIGluY2x1ZGUvZHJtL3Rpbnlkcm0vbWlwaS1kYmkuaCAgICAgICAgICAg ICAgICAgfCAxNiArKysrKysrKysrKysrKystCj4gICBpbmNsdWRlL2RybS90aW55ZHJtL3Rpbnlk cm0taGVscGVycy5oICAgICAgICAgIHwgIDIgKy0KPiAgIDggZmlsZXMgY2hhbmdlZCwgNjAgaW5z ZXJ0aW9ucygrKSwgMTQgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL3Rpbnlkcm0vY29yZS90aW55ZHJtLWhlbHBlcnMuYyBiL2RyaXZlcnMvZ3B1L2RybS90aW55 ZHJtL2NvcmUvdGlueWRybS1oZWxwZXJzLmMKPiBpbmRleCBiZjk2MDcyLi5mNWMxNzVlIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2NvcmUvdGlueWRybS1oZWxwZXJzLmMK PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9jb3JlL3Rpbnlkcm0taGVscGVycy5jCj4g QEAgLTQzNCw2ICs0MzQsNyBAQCBFWFBPUlRfU1lNQk9MKF90aW55ZHJtX2RiZ19zcGlfbWVzc2Fn ZSk7Cj4gICAgKiBAaGVhZGVyOiBPcHRpb25hbCBoZWFkZXIgdHJhbnNmZXIKPiAgICAqIEBicHc6 IEJpdHMgcGVyIHdvcmQKPiAgICAqIEBidWY6IEJ1ZmZlciB0byB0cmFuc2Zlcgo+ICsgKiBAcnhf YnVmOiBPcHRpb25hbCBkdW1teSBidWZmZXIKPiAgICAqIEBsZW46IEJ1ZmZlciBsZW5ndGgKPiAg ICAqCj4gICAgKiBUaGlzIFNQSSB0cmFuc2ZlciBoZWxwZXIgYnJlYWtzIHVwIHRoZSB0cmFuc2Zl ciBvZiBAYnVmIGludG8gY2h1bmtzIHdoaWNoCj4gQEAgLTQ0MiwxNiArNDQzLDIyIEBAIEVYUE9S VF9TWU1CT0woX3Rpbnlkcm1fZGJnX3NwaV9tZXNzYWdlKTsKPiAgICAqIGRvZXMgYSA4LWJpdCB0 cmFuc2Zlci4KPiAgICAqIElmIEBoZWFkZXIgaXMgc2V0LCBpdCBpcyBwcmVwZW5kZWQgdG8gZWFj aCBTUEkgbWVzc2FnZS4KPiAgICAqCj4gKyAqIFNvbWUgU1BJIGNvbnRyb2xsZXJzIG5lZWQgYW4g UlggYnVmZmVyIGV2ZW4gdGhvdWdoIHdlIGFyZSBub3QgcmVjZWl2aW5nCj4gKyAqIGFueXRoaW5n IHVzZWZ1bC4gQHJ4X2J1ZiBjYW4gYmUgcHJvdmlkZWQgc28gdGhhdCB0aGUgU1BJIGNvbnRyb2xs ZXIgZG9lcyBub3QKPiArICogaGF2ZSB0byByZWFsbG9jYXRlIHRoaXMgYnVmZmVyIG9uIGVhY2gg dHJhbnNmZXIuIFRoaXMgaXMgdXNlZnVsIGZvciBsYXJnZQo+ICsgKiB0cmFuc2ZlcnMsIGUuZy4g d2hlbiB1cGRhdGluZyB0aGUgR1JBTS4KPiArICoKPiAgICAqIFJldHVybnM6Cj4gICAgKiBaZXJv IG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiAgICAqLwo+ICAg aW50IHRpbnlkcm1fc3BpX3RyYW5zZmVyKHN0cnVjdCBzcGlfZGV2aWNlICpzcGksIHUzMiBzcGVl ZF9oeiwKPiAgIAkJCSBzdHJ1Y3Qgc3BpX3RyYW5zZmVyICpoZWFkZXIsIHU4IGJwdywgY29uc3Qg dm9pZCAqYnVmLAo+IC0JCQkgc2l6ZV90IGxlbikKPiArCQkJIHZvaWQgKnJ4X2J1Ziwgc2l6ZV90 IGxlbikKPiAgIHsKPiAgIAlzdHJ1Y3Qgc3BpX3RyYW5zZmVyIHRyID0gewo+ICAgCQkuYml0c19w ZXJfd29yZCA9IGJwdywKPiAgIAkJLnNwZWVkX2h6ID0gc3BlZWRfaHosCj4gKwkJLnJ4X2J1ZiA9 IHJ4X2J1ZiwKPiAgIAl9Owo+ICAgCXN0cnVjdCBzcGlfbWVzc2FnZSBtOwo+ICAgCXUxNiAqc3dh cF9idWYgPSBOVUxMOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9pbGk5 MjI1LmMgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9pbGk5MjI1LmMKPiBpbmRleCBhMDc1OTUw Li5jMTVmNDlhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2lsaTkyMjUu Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2lsaTkyMjUuYwo+IEBAIC0zMDAsNyAr MzAwLDcgQEAgc3RhdGljIGludCBpbGk5MjI1X2RiaV9jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAq bWlwaSwgdTggY21kLCB1OCAqcGFyLAo+ICAgCj4gICAJZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVw KG1pcGktPmRjLCAwKTsKPiAgIAlzcGVlZF9oeiA9IG1pcGlfZGJpX3NwaV9jbWRfbWF4X3NwZWVk KHNwaSwgMSk7Cj4gLQlyZXQgPSB0aW55ZHJtX3NwaV90cmFuc2ZlcihzcGksIHNwZWVkX2h6LCBO VUxMLCA4LCAmY21kLCAxKTsKPiArCXJldCA9IHRpbnlkcm1fc3BpX3RyYW5zZmVyKHNwaSwgc3Bl ZWRfaHosIE5VTEwsIDgsICZjbWQsIE5VTEwsIDEpOwo+ICAgCWlmIChyZXQgfHwgIW51bSkKPiAg IAkJcmV0dXJuIHJldDsKPiAgIAo+IEBAIC0zMTAsNyArMzEwLDggQEAgc3RhdGljIGludCBpbGk5 MjI1X2RiaV9jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21kLCB1OCAqcGFyLAo+ ICAgCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChtaXBpLT5kYywgMSk7Cj4gICAJc3BlZWRfaHog PSBtaXBpX2RiaV9zcGlfY21kX21heF9zcGVlZChzcGksIG51bSk7Cj4gICAKPiAtCXJldHVybiB0 aW55ZHJtX3NwaV90cmFuc2ZlcihzcGksIHNwZWVkX2h6LCBOVUxMLCBicHcsIHBhciwgbnVtKTsK PiArCXJldHVybiB0aW55ZHJtX3NwaV90cmFuc2ZlcihzcGksIHNwZWVkX2h6LCBOVUxMLCBicHcs IHBhciwgbWlwaS0+cnhfYnVmLAo+ICsJCQkJICAgIG51bSk7Cj4gICB9Cj4gICAKPiAgIHN0YXRp YyBjb25zdCB1MzIgaWxpOTIyNV9mb3JtYXRzW10gPSB7Cj4gQEAgLTQwMCw2ICs0MDEsNyBAQCBN T0RVTEVfREVWSUNFX1RBQkxFKHNwaSwgaWxpOTIyNV9pZCk7Cj4gICAKPiAgIHN0YXRpYyBpbnQg aWxpOTIyNV9wcm9iZShzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQo+ICAgewo+ICsJc2l6ZV90IGJ1 ZnNpemUgPSBtaXBpX2RiaV9tYXhfYnVmX3NpemUoJmlsaTkyMjVfbW9kZSk7Cj4gICAJc3RydWN0 IGRldmljZSAqZGV2ID0gJnNwaS0+ZGV2Owo+ICAgCXN0cnVjdCBtaXBpX2RiaSAqbWlwaTsKPiAg IAlzdHJ1Y3QgZ3Bpb19kZXNjICpyczsKPiBAQCAtNDI0LDcgKzQyNiw3IEBAIHN0YXRpYyBpbnQg aWxpOTIyNV9wcm9iZShzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQo+ICAgCj4gICAJZGV2aWNlX3By b3BlcnR5X3JlYWRfdTMyKGRldiwgInJvdGF0aW9uIiwgJnJvdGF0aW9uKTsKPiAgIAo+IC0JcmV0 ID0gbWlwaV9kYmlfc3BpX2luaXQoc3BpLCBtaXBpLCBycyk7Cj4gKwlyZXQgPSBtaXBpX2RiaV9z cGlfaW5pdChzcGksIG1pcGksIHJzLCBidWZzaXplKTsKPiAgIAlpZiAocmV0KQo+ICAgCQlyZXR1 cm4gcmV0Owo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL21pMDI4 M3F0LmMgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9taTAyODNxdC5jCj4gaW5kZXggNzljYjVh Zi4uYzNmYTY4MiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9taTAyODNx dC5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vbWkwMjgzcXQuYwo+IEBAIC0xNjks NiArMTY5LDcgQEAgTU9EVUxFX0RFVklDRV9UQUJMRShzcGksIG1pMDI4M3F0X2lkKTsKPiAgIAo+ ICAgc3RhdGljIGludCBtaTAyODNxdF9wcm9iZShzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQo+ICAg ewo+ICsJc2l6ZV90IGJ1ZnNpemUgPSBtaXBpX2RiaV9tYXhfYnVmX3NpemUoJm1pMDI4M3F0X21v ZGUpOwo+ICAgCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZzcGktPmRldjsKPiAgIAlzdHJ1Y3QgbWlw aV9kYmkgKm1pcGk7Cj4gICAJc3RydWN0IGdwaW9fZGVzYyAqZGM7Cj4gQEAgLTIwMSw3ICsyMDIs NyBAQCBzdGF0aWMgaW50IG1pMDI4M3F0X3Byb2JlKHN0cnVjdCBzcGlfZGV2aWNlICpzcGkpCj4g ICAKPiAgIAlkZXZpY2VfcHJvcGVydHlfcmVhZF91MzIoZGV2LCAicm90YXRpb24iLCAmcm90YXRp b24pOwo+ICAgCj4gLQlyZXQgPSBtaXBpX2RiaV9zcGlfaW5pdChzcGksIG1pcGksIGRjKTsKPiAr CXJldCA9IG1pcGlfZGJpX3NwaV9pbml0KHNwaSwgbWlwaSwgZGMsIGJ1ZnNpemUpOwo+ICAgCWlm IChyZXQpCj4gICAJCXJldHVybiByZXQ7Cj4gICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL3Rpbnlkcm0vbWlwaS1kYmkuYyBiL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL21pcGktZGJp LmMKPiBpbmRleCA3NWRkNjVjLi4xNmJlZTA2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS90aW55ZHJtL21pcGktZGJpLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9taXBp LWRiaS5jCj4gQEAgLTM2NCw3ICszNjQsNyBAQCBpbnQgbWlwaV9kYmlfaW5pdChzdHJ1Y3QgZGV2 aWNlICpkZXYsIHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwKPiAgIAkJICBzdHJ1Y3QgZHJtX2RyaXZl ciAqZHJpdmVyLAo+ICAgCQkgIGNvbnN0IHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlLCB1 bnNpZ25lZCBpbnQgcm90YXRpb24pCj4gICB7Cj4gLQlzaXplX3QgYnVmc2l6ZSA9IG1vZGUtPnZk aXNwbGF5ICogbW9kZS0+aGRpc3BsYXkgKiBzaXplb2YodTE2KTsKPiArCXNpemVfdCBidWZzaXpl ID0gbWlwaV9kYmlfbWF4X2J1Zl9zaXplKG1vZGUpOwo+ICAgCXN0cnVjdCB0aW55ZHJtX2Rldmlj ZSAqdGRldiA9ICZtaXBpLT50aW55ZHJtOwo+ICAgCWludCByZXQ7Cj4gICAKPiBAQCAtODQ4LDcg Kzg0OCw3IEBAIHN0YXRpYyBpbnQgbWlwaV9kYmlfdHlwZWMzX2NvbW1hbmQoc3RydWN0IG1pcGlf ZGJpICptaXBpLCB1OCBjbWQsCj4gICAKPiAgIAlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAobWlw aS0+ZGMsIDApOwo+ICAgCXNwZWVkX2h6ID0gbWlwaV9kYmlfc3BpX2NtZF9tYXhfc3BlZWQoc3Bp LCAxKTsKPiAtCXJldCA9IHRpbnlkcm1fc3BpX3RyYW5zZmVyKHNwaSwgc3BlZWRfaHosIE5VTEws IDgsICZjbWQsIDEpOwo+ICsJcmV0ID0gdGlueWRybV9zcGlfdHJhbnNmZXIoc3BpLCBzcGVlZF9o eiwgTlVMTCwgOCwgJmNtZCwgTlVMTCwgMSk7Cj4gICAJaWYgKHJldCB8fCAhbnVtKQo+ICAgCQly ZXR1cm4gcmV0Owo+ICAgCj4gQEAgLTg1OCw3ICs4NTgsOCBAQCBzdGF0aWMgaW50IG1pcGlfZGJp X3R5cGVjM19jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21kLAo+ICAgCWdwaW9k X3NldF92YWx1ZV9jYW5zbGVlcChtaXBpLT5kYywgMSk7Cj4gICAJc3BlZWRfaHogPSBtaXBpX2Ri aV9zcGlfY21kX21heF9zcGVlZChzcGksIG51bSk7Cj4gICAKPiAtCXJldHVybiB0aW55ZHJtX3Nw aV90cmFuc2ZlcihzcGksIHNwZWVkX2h6LCBOVUxMLCBicHcsIHBhciwgbnVtKTsKPiArCXJldHVy biB0aW55ZHJtX3NwaV90cmFuc2ZlcihzcGksIHNwZWVkX2h6LCBOVUxMLCBicHcsIHBhciwgbWlw aS0+cnhfYnVmLAo+ICsJCQkJICAgIG51bSk7Cj4gICB9Cj4gICAKPiAgIC8qKgo+IEBAIC04NjYs NiArODY3LDcgQEAgc3RhdGljIGludCBtaXBpX2RiaV90eXBlYzNfY29tbWFuZChzdHJ1Y3QgbWlw aV9kYmkgKm1pcGksIHU4IGNtZCwKPiAgICAqIEBzcGk6IFNQSSBkZXZpY2UKPiAgICAqIEBtaXBp OiAmbWlwaV9kYmkgc3RydWN0dXJlIHRvIGluaXRpYWxpemUKPiAgICAqIEBkYzogRC9DIGdwaW8g KG9wdGlvbmFsKQo+ICsgKiBAbWF4X3NpemU6IE1heGltdW0gVFggYnVmZmVyIHNpemUgbmVlZGVk IGJ5IHRoZSBjYWxsZXIKPiAgICAqCj4gICAgKiBUaGlzIGZ1bmN0aW9uIHNldHMgJm1pcGlfZGJp LT5jb21tYW5kLCBlbmFibGVzICZtaXBpLT5yZWFkX2NvbW1hbmRzIGZvciB0aGUKPiAgICAqIHVz dWFsIHJlYWQgY29tbWFuZHMuIEl0IHNob3VsZCBiZSBmb2xsb3dlZCBieSBhIGNhbGwgdG8gbWlw aV9kYmlfaW5pdCgpIG9yCj4gQEAgLTg4NCw3ICs4ODYsNyBAQCBzdGF0aWMgaW50IG1pcGlfZGJp X3R5cGVjM19jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21kLAo+ICAgICogWmVy byBvbiBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gICAgKi8KPiAg IGludCBtaXBpX2RiaV9zcGlfaW5pdChzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCBzdHJ1Y3QgbWlw aV9kYmkgKm1pcGksCj4gLQkJICAgICAgc3RydWN0IGdwaW9fZGVzYyAqZGMpCj4gKwkJICAgICAg c3RydWN0IGdwaW9fZGVzYyAqZGMsIHNpemVfdCBtYXhfc2l6ZSkKPiAgIHsKPiAgIAlzaXplX3Qg dHhfc2l6ZSA9IHRpbnlkcm1fc3BpX21heF90cmFuc2Zlcl9zaXplKHNwaSwgMCk7Cj4gICAJc3Ry dWN0IGRldmljZSAqZGV2ID0gJnNwaS0+ZGV2Owo+IEBAIC05MzAsNiArOTMyLDE2IEBAIGludCBt aXBpX2RiaV9zcGlfaW5pdChzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCBzdHJ1Y3QgbWlwaV9kYmkg Km1pcGksCj4gICAJCQlyZXR1cm4gLUVOT01FTTsKPiAgIAl9Cj4gICAKPiArCS8qCj4gKwkgKiBB bGxvY2F0ZSBhIGR1bW15IFJYIGJ1ZmZlciBpZiBuZWVkZWQsIG90aGVyd2lzZSB0aGUgU1BJIGNv bnRyb2xsZXIKPiArCSAqIHdpbGwgaGF2ZSB0byByZWFsbG9jYXRlIGEgbmV3IGJ1ZmZlciBvbiBl YWNoIHRyYW5zZmVyLgo+ICsJICovCj4gKwlpZiAoc3BpLT5jb250cm9sbGVyLT5mbGFncyAmIFNQ SV9DT05UUk9MTEVSX01VU1RfUlgpIHsKPiArCQltaXBpLT5yeF9idWYgPSBkZXZtX2ttYWxsb2Mo ZGV2LCBtYXhfc2l6ZSwgR0ZQX0tFUk5FTCk7Cj4gKwkJaWYgKCFtaXBpLT5yeF9idWYpCj4gKwkJ CXJldHVybiAtRU5PTUVNOwo+ICsJfQo+ICsKPiAgIAlEUk1fREVCVUdfRFJJVkVSKCJTUEkgc3Bl ZWQ6ICV1TUh6XG4iLCBzcGktPm1heF9zcGVlZF9oeiAvIDEwMDAwMDApOwo+ICAgCj4gICAJcmV0 dXJuIDA7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL3N0NzU4Ni5jIGIv ZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NTg2LmMKPiBpbmRleCBhNjM5NmVmLi5iYjBkNTVk IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL3N0NzU4Ni5jCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NTg2LmMKPiBAQCAtNDIsNiArNDIsMTQgQEAKPiAg ICNkZWZpbmUgU1Q3NTg2X0RJU1BfQ1RSTF9NWAlCSVQoNikKPiAgICNkZWZpbmUgU1Q3NTg2X0RJ U1BfQ1RSTF9NWQlCSVQoNykKPiAgIAo+ICtzdGF0aWMgaW5saW5lIHNpemVfdCBzdDc1ODZfYnVm X21heF9zaXplKGNvbnN0IHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKQo+ICt7Cj4gKwlz aXplX3Qgd2lkdGggPSAobW9kZS0+aGRpc3BsYXkgKyAyKSAvIDM7IC8qIDMgcGl4ZWxzIHBlciBi eXRlICovCj4gKwlzaXplX3QgaGVpZ2h0ID0gbW9kZS0+dmRpc3BsYXk7Cj4gKwo+ICsJcmV0dXJu IHdpZHRoICogaGVpZ2h0Owo+ICt9Cj4gKwo+ICAgLyoKPiAgICAqIFRoZSBTVDc1ODYgY29udHJv bGxlciBoYXMgYW4gdW51c3VhbCBwaXhlbCBmb3JtYXQgd2hlcmUgMmJwcCBncmF5c2NhbGUgaXMK PiAgICAqIHBhY2tlZCAzIHBpeGVscyBwZXIgYnl0ZSB3aXRoIHRoZSBmaXJzdCB0d28gcGl4ZWxz IHVzaW5nIDMgYml0cyBhbmQgdGhlIDNyZAo+IEBAIC0yNjMsNyArMjcxLDcgQEAgc3RhdGljIGlu dCBzdDc1ODZfaW5pdChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwK PiAgIAkJc3RydWN0IGRybV9kcml2ZXIgKmRyaXZlciwgY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5 X21vZGUgKm1vZGUsCj4gICAJCXVuc2lnbmVkIGludCByb3RhdGlvbikKPiAgIHsKPiAtCXNpemVf dCBidWZzaXplID0gKG1vZGUtPnZkaXNwbGF5ICsgMikgLyAzICogbW9kZS0+aGRpc3BsYXk7Cj4g KwlzaXplX3QgYnVmc2l6ZSA9IHN0NzU4Nl9idWZfbWF4X3NpemUobW9kZSk7Cj4gICAJc3RydWN0 IHRpbnlkcm1fZGV2aWNlICp0ZGV2ID0gJm1pcGktPnRpbnlkcm07Cj4gICAJaW50IHJldDsKPiAg IAo+IEBAIC0zMzcsNiArMzQ1LDcgQEAgTU9EVUxFX0RFVklDRV9UQUJMRShzcGksIHN0NzU4Nl9p ZCk7Cj4gICAKPiAgIHN0YXRpYyBpbnQgc3Q3NTg2X3Byb2JlKHN0cnVjdCBzcGlfZGV2aWNlICpz cGkpCj4gICB7Cj4gKwlzaXplX3QgYnVmc2l6ZSA9IHN0NzU4Nl9idWZfbWF4X3NpemUoJnN0NzU4 Nl9tb2RlKTsKPiAgIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmc3BpLT5kZXY7Cj4gICAJc3RydWN0 IG1pcGlfZGJpICptaXBpOwo+ICAgCXN0cnVjdCBncGlvX2Rlc2MgKmEwOwo+IEBAIC0zNjEsNyAr MzcwLDcgQEAgc3RhdGljIGludCBzdDc1ODZfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkK PiAgIAo+ICAgCWRldmljZV9wcm9wZXJ0eV9yZWFkX3UzMihkZXYsICJyb3RhdGlvbiIsICZyb3Rh dGlvbik7Cj4gICAKPiAtCXJldCA9IG1pcGlfZGJpX3NwaV9pbml0KHNwaSwgbWlwaSwgYTApOwo+ ICsJcmV0ID0gbWlwaV9kYmlfc3BpX2luaXQoc3BpLCBtaXBpLCBhMCwgYnVmc2l6ZSk7Cj4gICAJ aWYgKHJldCkKPiAgIAkJcmV0dXJuIHJldDsKPiAgIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vdGlueWRybS9zdDc3MzVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9zdDc3MzVy LmMKPiBpbmRleCAwOGI0ZmIxLi5jMDQ3YmFjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS90aW55ZHJtL3N0NzczNXIuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL3N0Nzcz NXIuYwo+IEBAIC0xNDEsNiArMTQxLDcgQEAgTU9EVUxFX0RFVklDRV9UQUJMRShzcGksIHN0Nzcz NXJfaWQpOwo+ICAgCj4gICBzdGF0aWMgaW50IHN0NzczNXJfcHJvYmUoc3RydWN0IHNwaV9kZXZp Y2UgKnNwaSkKPiAgIHsKPiArCXNpemVfdCBidWZzaXplID0gbWlwaV9kYmlfbWF4X2J1Zl9zaXpl KCZqZF90MTgwMDNfdDAxX21vZGUpOwo+ICAgCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZzcGktPmRl djsKPiAgIAlzdHJ1Y3QgbWlwaV9kYmkgKm1pcGk7Cj4gICAJc3RydWN0IGdwaW9fZGVzYyAqZGM7 Cj4gQEAgLTE2OSw3ICsxNzAsNyBAQCBzdGF0aWMgaW50IHN0NzczNXJfcHJvYmUoc3RydWN0IHNw aV9kZXZpY2UgKnNwaSkKPiAgIAo+ICAgCWRldmljZV9wcm9wZXJ0eV9yZWFkX3UzMihkZXYsICJy b3RhdGlvbiIsICZyb3RhdGlvbik7Cj4gICAKPiAtCXJldCA9IG1pcGlfZGJpX3NwaV9pbml0KHNw aSwgbWlwaSwgZGMpOwo+ICsJcmV0ID0gbWlwaV9kYmlfc3BpX2luaXQoc3BpLCBtaXBpLCBkYywg YnVmc2l6ZSk7Cj4gICAJaWYgKHJldCkKPiAgIAkJcmV0dXJuIHJldDsKPiAgIAo+IGRpZmYgLS1n aXQgYS9pbmNsdWRlL2RybS90aW55ZHJtL21pcGktZGJpLmggYi9pbmNsdWRlL2RybS90aW55ZHJt L21pcGktZGJpLmgKPiBpbmRleCA0NGU4MjRhLi5kZWVlODYyIDEwMDY0NAo+IC0tLSBhL2luY2x1 ZGUvZHJtL3Rpbnlkcm0vbWlwaS1kYmkuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL3Rpbnlkcm0vbWlw aS1kYmkuaAo+IEBAIC0zMSw2ICszMSw3IEBAIHN0cnVjdCByZWd1bGF0b3I7Cj4gICAgKiBAdHhf YnVmOiBCdWZmZXIgdXNlZCBmb3IgdHJhbnNmZXIgKGNvcHkgY2xpcCByZWN0IGFyZWEpCj4gICAg KiBAdHhfYnVmOTogQnVmZmVyIHVzZWQgZm9yIE9wdGlvbiAxIDktYml0IGNvbnZlcnNpb24KPiAg ICAqIEB0eF9idWY5X2xlbjogU2l6ZSBvZiB0eF9idWY5Lgo+ICsgKiBAcnhfYnVmOiBPcHRpb25h bCBkdW1teSBSWCBidWZmZXIuCj4gICAgKiBAc3dhcF9ieXRlczogU3dhcCBieXRlcyBpbiBidWZm ZXIgYmVmb3JlIHRyYW5zZmVyCj4gICAgKiBAcmVzZXQ6IE9wdGlvbmFsIHJlc2V0IGdwaW8KPiAg ICAqIEByb3RhdGlvbjogaW5pdGlhbCByb3RhdGlvbiBpbiBkZWdyZWVzIENvdW50ZXIgQ2xvY2sg V2lzZQo+IEBAIC00OCw2ICs0OSw3IEBAIHN0cnVjdCBtaXBpX2RiaSB7Cj4gICAJdTE2ICp0eF9i dWY7Cj4gICAJdm9pZCAqdHhfYnVmOTsKPiAgIAlzaXplX3QgdHhfYnVmOV9sZW47Cj4gKwl2b2lk ICpyeF9idWY7Cj4gICAJYm9vbCBzd2FwX2J5dGVzOwo+ICAgCXN0cnVjdCBncGlvX2Rlc2MgKnJl c2V0Owo+ICAgCXVuc2lnbmVkIGludCByb3RhdGlvbjsKPiBAQCAtNjIsNyArNjQsNyBAQCBtaXBp X2RiaV9mcm9tX3Rpbnlkcm0oc3RydWN0IHRpbnlkcm1fZGV2aWNlICp0ZGV2KQo+ICAgfQo+ICAg Cj4gICBpbnQgbWlwaV9kYmlfc3BpX2luaXQoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgc3RydWN0 IG1pcGlfZGJpICptaXBpLAo+IC0JCSAgICAgIHN0cnVjdCBncGlvX2Rlc2MgKmRjKTsKPiArCQkg ICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICpkYywgc2l6ZV90IG1heF9zaXplKTsKPiAgIGludCBtaXBp X2RiaV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IG1pcGlfZGJpICptaXBpLAo+ICAg CQkgIGNvbnN0IHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcyAqcGlwZV9mdW5j cywKPiAgIAkJICBzdHJ1Y3QgZHJtX2RyaXZlciAqZHJpdmVyLAo+IEBAIC03OSw2ICs4MSwxOCBA QCBpbnQgbWlwaV9kYmlfY29tbWFuZF9yZWFkKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21k LCB1OCAqdmFsKTsKPiAgIGludCBtaXBpX2RiaV9jb21tYW5kX2J1ZihzdHJ1Y3QgbWlwaV9kYmkg Km1pcGksIHU4IGNtZCwgdTggKmRhdGEsIHNpemVfdCBsZW4pOwo+ICAgaW50IG1pcGlfZGJpX2J1 Zl9jb3B5KHZvaWQgKmRzdCwgc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIsCj4gICAJCSAgICAg IHN0cnVjdCBkcm1fY2xpcF9yZWN0ICpjbGlwLCBib29sIHN3YXApOwo+ICsKPiArLyoqCj4gKyAq IG1pcGlfZGJpX21heF9idWZfc2l6ZSAtIEdldCB0aGUgbWF4aW11bSByZXF1aXJlZCBmcmFtZWJ1 ZmZlciBtZW1vcnkgc2l6ZQo+ICsgKiBAbW9kZTogVGhlIGRpc3BsYXkgbW9kZSBkYXRhCj4gKyAq Cj4gKyAqIENvbXB1dGVzIHRoZSBtYXhpbXVtIGJ1ZmZlciBzaXplIG5lZWRlZCBmb3IgYSAyIGJ5 dGUgcGVyIHBpeGVsIGRpc3BsYXkuCj4gKyAqLwo+ICtzdGF0aWMgaW5saW5lIHNpemVfdCBtaXBp X2RiaV9tYXhfYnVmX3NpemUoY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpCj4g K3sKPiArCXJldHVybiBtb2RlLT5oZGlzcGxheSAqIG1vZGUtPnZkaXNwbGF5ICogc2l6ZW9mKHUx Nik7Cj4gK30KPiArCj4gICAvKioKPiAgICAqIG1pcGlfZGJpX2NvbW1hbmQgLSBNSVBJIERDUyBj b21tYW5kIHdpdGggb3B0aW9uYWwgcGFyYW1ldGVyKHMpCj4gICAgKiBAbWlwaTogTUlQSSBzdHJ1 Y3R1cmUKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vdGlueWRybS90aW55ZHJtLWhlbHBlcnMu aCBiL2luY2x1ZGUvZHJtL3Rpbnlkcm0vdGlueWRybS1oZWxwZXJzLmgKPiBpbmRleCBkNTU0ZGVk Li5lNWU4ZjU5IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvZHJtL3Rpbnlkcm0vdGlueWRybS1oZWxw ZXJzLmgKPiArKysgYi9pbmNsdWRlL2RybS90aW55ZHJtL3Rpbnlkcm0taGVscGVycy5oCj4gQEAg LTU0LDcgKzU0LDcgQEAgc2l6ZV90IHRpbnlkcm1fc3BpX21heF90cmFuc2Zlcl9zaXplKHN0cnVj dCBzcGlfZGV2aWNlICpzcGksIHNpemVfdCBtYXhfbGVuKTsKPiAgIGJvb2wgdGlueWRybV9zcGlf YnB3X3N1cHBvcnRlZChzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCB1OCBicHcpOwo+ICAgaW50IHRp bnlkcm1fc3BpX3RyYW5zZmVyKHN0cnVjdCBzcGlfZGV2aWNlICpzcGksIHUzMiBzcGVlZF9oeiwK PiAgIAkJCSBzdHJ1Y3Qgc3BpX3RyYW5zZmVyICpoZWFkZXIsIHU4IGJwdywgY29uc3Qgdm9pZCAq YnVmLAo+IC0JCQkgc2l6ZV90IGxlbik7Cj4gKwkJCSB2b2lkICpyeF9idWYsIHNpemVfdCBsZW4p Owo+ICAgdm9pZCBfdGlueWRybV9kYmdfc3BpX21lc3NhZ2Uoc3RydWN0IHNwaV9kZXZpY2UgKnNw aSwgc3RydWN0IHNwaV9tZXNzYWdlICptKTsKPiAgIAo+ICAgI2lmZGVmIERFQlVHCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK