From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:45866 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387484AbeHBQta (ORCPT ); Thu, 2 Aug 2018 12:49:30 -0400 From: Laurent Pinchart To: Kieran Bingham Cc: Kieran Bingham , linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, Kieran Bingham Subject: Re: [PATCH v5 09/11] media: vsp1: Provide support for extended command pools Date: Thu, 02 Aug 2018 17:58:35 +0300 Message-ID: <5383123.6Vee3TadY2@avalon> In-Reply-To: <8b2969c3371d9b132dd492cdddaf11d0bf5b659f.1531857988.git-series.kieran.bingham+renesas@ideasonboard.com> References: <8b2969c3371d9b132dd492cdddaf11d0bf5b659f.1531857988.git-series.kieran.bingham+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: Hi Kieran, Thank you for the patch. On Tuesday, 17 July 2018 23:35:51 EEST Kieran Bingham wrote: > From: Kieran Bingham > > VSPD and VSP-DL devices can provide extended display lists supporting > extended command display list objects. > > These extended commands require their own dma memory areas for a header > and body specific to the command type. > > Implement a command pool to allocate all necessary memory in a single > DMA allocation to reduce pressure on the TLB, and provide convenient > re-usable command objects for the entities to utilise. > > Signed-off-by: Kieran Bingham > > --- > v2: > - Fix spelling typo in commit message > - constify, and staticify the instantiation of vsp1_extended_commands > - s/autfld_cmds/autofld_cmds/ > - staticify cmd pool functions (Thanks kbuild-bot) > > v5: > - Rename vsp1_dl_ext_cmd_header -> vsp1_pre_ext_dl_body > - fixup vsp1_cmd_pool structure documentation > - Rename dlm->autofld_cmds dlm->cmdpool > - Separate out the instatiation of vsp1_extended_commands > - Move initialisation of lock, and lists in vsp1_dl_cmd_pool_create to > immediately after allocation > - simplify vsp1_dlm_get_autofld_cmd > - Rename vsp1_dl_get_autofld_cmd() to vsp1_dl_get_pre_cmd() and moved > to "Display List Extended Command Management" section of vsp1_dl > > drivers/media/platform/vsp1/vsp1_dl.c | 194 +++++++++++++++++++++++++++- > drivers/media/platform/vsp1/vsp1_dl.h | 3 +- > 2 files changed, 197 insertions(+) > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > b/drivers/media/platform/vsp1/vsp1_dl.c index 2fffe977aa35..d5b3c24d160c > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.c > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > @@ -141,6 +141,30 @@ struct vsp1_dl_body_pool { > }; > > /** > + * struct vsp1_cmd_pool - Display List commands pool > + * @dma: DMA address of the entries > + * @size: size of the full DMA memory pool in bytes > + * @mem: CPU memory pointer for the pool > + * @cmds: Array of command structures for the pool > + * @free: Free pool entries > + * @lock: Protects the free list > + * @vsp1: the VSP1 device > + */ > +struct vsp1_dl_cmd_pool { > + /* DMA allocation */ > + dma_addr_t dma; > + size_t size; > + void *mem; > + > + struct vsp1_dl_ext_cmd *cmds; > + struct list_head free; > + > + spinlock_t lock; > + > + struct vsp1_device *vsp1; > +}; > + > +/** > * struct vsp1_dl_list - Display list > * @list: entry in the display list manager lists > * @dlm: the display list manager > @@ -186,6 +210,7 @@ struct vsp1_dl_list { > * @queued: list queued to the hardware (written to the DL registers) > * @pending: list waiting to be queued to the hardware > * @pool: body pool for the display list bodies > + * @autofld_cmds: command pool to support auto-fld interlaced mode > */ > struct vsp1_dl_manager { > unsigned int index; > @@ -199,6 +224,7 @@ struct vsp1_dl_manager { > struct vsp1_dl_list *pending; > > struct vsp1_dl_body_pool *pool; > + struct vsp1_dl_cmd_pool *cmdpool; > }; > > /* > --------------------------------------------------------------------------- > -- @@ -362,6 +388,157 @@ void vsp1_dl_body_write(struct vsp1_dl_body *dlb, > u32 reg, u32 data) } > > /* > --------------------------------------------------------------------------- > -- + * Display List Extended Command Management > + */ > + > +enum vsp1_extcmd_type { > + VSP1_EXTCMD_AUTODISP, > + VSP1_EXTCMD_AUTOFLD, > +}; > + > +struct vsp1_extended_command_info { > + u16 opcode; > + size_t body_size; > +}; > + > +static const struct vsp1_extended_command_info vsp1_extended_commands[] = { > + [VSP1_EXTCMD_AUTODISP] = { 0x02, 96 }, > + [VSP1_EXTCMD_AUTOFLD] = { 0x03, 160 }, > +}; > + > +/** > + * vsp1_dl_cmd_pool_create - Create a pool of commands from a single > allocation + * @vsp1: The VSP1 device > + * @type: The command pool type > + * @num_cmds: The number of commands to allocate > + * > + * Allocate a pool of commands each with enough memory to contain the > private + * data of each command. The allocation sizes are dependent upon > the command + * type. > + * > + * Return a pointer to the pool on success or NULL if memory can't be > allocated. + */ > +static struct vsp1_dl_cmd_pool * > +vsp1_dl_cmd_pool_create(struct vsp1_device *vsp1, enum vsp1_extcmd_type > type, + unsigned int num_cmds) > +{ > + struct vsp1_dl_cmd_pool *pool; > + unsigned int i; > + size_t cmd_size; > + > + pool = kzalloc(sizeof(*pool), GFP_KERNEL); > + if (!pool) > + return NULL; > + > + spin_lock_init(&pool->lock); > + INIT_LIST_HEAD(&pool->free); > + > + pool->cmds = kcalloc(num_cmds, sizeof(*pool->cmds), GFP_KERNEL); > + if (!pool->cmds) { > + kfree(pool); > + return NULL; > + } > + > + cmd_size = sizeof(struct vsp1_pre_ext_dl_body) + > + vsp1_extended_commands[type].body_size; > + cmd_size = ALIGN(cmd_size, 16); > + > + pool->size = cmd_size * num_cmds; > + pool->mem = dma_alloc_wc(vsp1->bus_master, pool->size, &pool->dma, > + GFP_KERNEL); > + if (!pool->mem) { > + kfree(pool->cmds); > + kfree(pool); > + return NULL; > + } > + > + for (i = 0; i < num_cmds; ++i) { > + struct vsp1_dl_ext_cmd *cmd = &pool->cmds[i]; > + size_t cmd_offset = i * cmd_size; > + /* data_offset must be 16 byte aligned for DMA. */ > + size_t data_offset = sizeof(struct vsp1_pre_ext_dl_body) + > + cmd_offset; > + > + cmd->pool = pool; > + cmd->opcode = vsp1_extended_commands[type].opcode; > + > + /* > + * TODO: Auto-disp can utilise more than one extended body > + * command per cmd. > + */ > + cmd->num_cmds = 1; > + cmd->cmds = pool->mem + cmd_offset; > + cmd->cmd_dma = pool->dma + cmd_offset; > + > + cmd->data = pool->mem + data_offset; > + cmd->data_dma = pool->dma + data_offset; > + > + list_add_tail(&cmd->free, &pool->free); > + } > + > + return pool; > +} > + > +static > +struct vsp1_dl_ext_cmd *vsp1_dl_ext_cmd_get(struct vsp1_dl_cmd_pool *pool) > +{ > + struct vsp1_dl_ext_cmd *cmd = NULL; > + unsigned long flags; > + > + spin_lock_irqsave(&pool->lock, flags); > + > + if (!list_empty(&pool->free)) { > + cmd = list_first_entry(&pool->free, struct vsp1_dl_ext_cmd, > + free); > + list_del(&cmd->free); > + } > + > + spin_unlock_irqrestore(&pool->lock, flags); > + > + return cmd; > +} > + > +static void vsp1_dl_ext_cmd_put(struct vsp1_dl_ext_cmd *cmd) > +{ > + unsigned long flags; > + > + if (!cmd) > + return; > + > + /* Reset flags, these mark data usage. */ > + cmd->flags = 0; > + > + spin_lock_irqsave(&cmd->pool->lock, flags); > + list_add_tail(&cmd->free, &cmd->pool->free); > + spin_unlock_irqrestore(&cmd->pool->lock, flags); > +} > + > +static void vsp1_dl_ext_cmd_pool_destroy(struct vsp1_dl_cmd_pool *pool) > +{ > + if (!pool) > + return; > + > + if (pool->mem) > + dma_free_wc(pool->vsp1->bus_master, pool->size, pool->mem, > + pool->dma); > + > + kfree(pool->cmds); > + kfree(pool); > +} > + > +struct vsp1_dl_ext_cmd *vsp1_dl_get_pre_cmd(struct vsp1_dl_list *dl) > +{ > + struct vsp1_dl_manager *dlm = dl->dlm; > + > + if (dl->pre_cmd) > + return dl->pre_cmd; > + > + dl->pre_cmd = vsp1_dl_ext_cmd_get(dlm->cmdpool); > + > + return dl->pre_cmd; > +} > + > +/* > --------------------------------------------------------------------------- > - * Display List Transaction Management > */ > > @@ -463,6 +640,12 @@ static void __vsp1_dl_list_put(struct vsp1_dl_list *dl) > > vsp1_dl_list_bodies_put(dl); > > + vsp1_dl_ext_cmd_put(dl->pre_cmd); > + vsp1_dl_ext_cmd_put(dl->post_cmd); > + > + dl->pre_cmd = NULL; > + dl->post_cmd = NULL; > + > /* > * body0 is reused as as an optimisation as presently every display list > * has at least one body, thus we reinitialise the entries list. > @@ -913,6 +1096,15 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct > vsp1_device *vsp1, list_add_tail(&dl->list, &dlm->free); > } > > + if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) { > + dlm->cmdpool = vsp1_dl_cmd_pool_create(vsp1, > + VSP1_EXTCMD_AUTOFLD, prealloc); > + if (!dlm->cmdpool) { > + vsp1_dlm_destroy(dlm); > + return NULL; > + } > + } > + > return dlm; > } > > @@ -929,4 +1121,6 @@ void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm) > } > > vsp1_dl_body_pool_destroy(dlm->pool); > + vsp1_dl_ext_cmd_pool_destroy(dlm->cmdpool); > } > + Extra blank line. Apart from that, Reviewed-by: Laurent Pinchart > diff --git a/drivers/media/platform/vsp1/vsp1_dl.h > b/drivers/media/platform/vsp1/vsp1_dl.h index afefd5bfa136..125750dc8b5c > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.h > +++ b/drivers/media/platform/vsp1/vsp1_dl.h > @@ -22,6 +22,7 @@ struct vsp1_dl_manager; > > /** > * struct vsp1_dl_ext_cmd - Extended Display command > + * @pool: pool to which this command belongs > * @free: entry in the pool of free commands list > * @opcode: command type opcode > * @flags: flags used by the command > @@ -32,6 +33,7 @@ struct vsp1_dl_manager; > * @data_dma: DMA address for command-specific data > */ > struct vsp1_dl_ext_cmd { > + struct vsp1_dl_cmd_pool *pool; > struct list_head free; > > u8 opcode; > @@ -58,6 +60,7 @@ struct vsp1_dl_body *vsp1_dlm_dl_body_get(struct > vsp1_dl_manager *dlm); struct vsp1_dl_list *vsp1_dl_list_get(struct > vsp1_dl_manager *dlm); void vsp1_dl_list_put(struct vsp1_dl_list *dl); > struct vsp1_dl_body *vsp1_dl_list_get_body0(struct vsp1_dl_list *dl); > +struct vsp1_dl_ext_cmd *vsp1_dl_get_pre_cmd(struct vsp1_dl_list *dl); > void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool internal); > > struct vsp1_dl_body_pool * -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v5 09/11] media: vsp1: Provide support for extended command pools Date: Thu, 02 Aug 2018 17:58:35 +0300 Message-ID: <5383123.6Vee3TadY2@avalon> References: <8b2969c3371d9b132dd492cdddaf11d0bf5b659f.1531857988.git-series.kieran.bingham+renesas@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2EECF6E5B5 for ; Thu, 2 Aug 2018 14:57:54 +0000 (UTC) In-Reply-To: <8b2969c3371d9b132dd492cdddaf11d0bf5b659f.1531857988.git-series.kieran.bingham+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, Kieran Bingham , Kieran Bingham , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBUdWVzZGF5LCAxNyBKdWx5 IDIwMTggMjM6MzU6NTEgRUVTVCBLaWVyYW4gQmluZ2hhbSB3cm90ZToKPiBGcm9tOiBLaWVyYW4g QmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+IAo+IFZT UEQgYW5kIFZTUC1ETCBkZXZpY2VzIGNhbiBwcm92aWRlIGV4dGVuZGVkIGRpc3BsYXkgbGlzdHMg c3VwcG9ydGluZwo+IGV4dGVuZGVkIGNvbW1hbmQgZGlzcGxheSBsaXN0IG9iamVjdHMuCj4gCj4g VGhlc2UgZXh0ZW5kZWQgY29tbWFuZHMgcmVxdWlyZSB0aGVpciBvd24gZG1hIG1lbW9yeSBhcmVh cyBmb3IgYSBoZWFkZXIKPiBhbmQgYm9keSBzcGVjaWZpYyB0byB0aGUgY29tbWFuZCB0eXBlLgo+ IAo+IEltcGxlbWVudCBhIGNvbW1hbmQgcG9vbCB0byBhbGxvY2F0ZSBhbGwgbmVjZXNzYXJ5IG1l bW9yeSBpbiBhIHNpbmdsZQo+IERNQSBhbGxvY2F0aW9uIHRvIHJlZHVjZSBwcmVzc3VyZSBvbiB0 aGUgVExCLCBhbmQgcHJvdmlkZSBjb252ZW5pZW50Cj4gcmUtdXNhYmxlIGNvbW1hbmQgb2JqZWN0 cyBmb3IgdGhlIGVudGl0aWVzIHRvIHV0aWxpc2UuCj4gCj4gU2lnbmVkLW9mZi1ieTogS2llcmFu IEJpbmdoYW0gPGtpZXJhbi5iaW5naGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAKPiAt LS0KPiB2MjoKPiAgLSBGaXggc3BlbGxpbmcgdHlwbyBpbiBjb21taXQgbWVzc2FnZQo+ICAtIGNv bnN0aWZ5LCBhbmQgc3RhdGljaWZ5IHRoZSBpbnN0YW50aWF0aW9uIG9mIHZzcDFfZXh0ZW5kZWRf Y29tbWFuZHMKPiAgLSBzL2F1dGZsZF9jbWRzL2F1dG9mbGRfY21kcy8KPiAgLSBzdGF0aWNpZnkg Y21kIHBvb2wgZnVuY3Rpb25zIChUaGFua3Mga2J1aWxkLWJvdCkKPiAKPiB2NToKPiAgLSBSZW5h bWUgdnNwMV9kbF9leHRfY21kX2hlYWRlciAtPiB2c3AxX3ByZV9leHRfZGxfYm9keQo+ICAtIGZp eHVwIHZzcDFfY21kX3Bvb2wgc3RydWN0dXJlIGRvY3VtZW50YXRpb24KPiAgLSBSZW5hbWUgZGxt LT5hdXRvZmxkX2NtZHMgZGxtLT5jbWRwb29sCj4gIC0gU2VwYXJhdGUgb3V0IHRoZSBpbnN0YXRp YXRpb24gb2YgdnNwMV9leHRlbmRlZF9jb21tYW5kcwo+ICAtIE1vdmUgaW5pdGlhbGlzYXRpb24g b2YgbG9jaywgYW5kIGxpc3RzIGluIHZzcDFfZGxfY21kX3Bvb2xfY3JlYXRlIHRvCj4gICAgaW1t ZWRpYXRlbHkgYWZ0ZXIgYWxsb2NhdGlvbgo+ICAtIHNpbXBsaWZ5IHZzcDFfZGxtX2dldF9hdXRv ZmxkX2NtZAo+ICAtIFJlbmFtZSB2c3AxX2RsX2dldF9hdXRvZmxkX2NtZCgpIHRvIHZzcDFfZGxf Z2V0X3ByZV9jbWQoKSBhbmQgbW92ZWQKPiAgICB0byAiRGlzcGxheSBMaXN0IEV4dGVuZGVkIENv bW1hbmQgTWFuYWdlbWVudCIgc2VjdGlvbiBvZiB2c3AxX2RsCj4gCj4gIGRyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX2RsLmMgfCAxOTQgKysrKysrKysrKysrKysrKysrKysrKysrKysr LQo+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oIHwgICAzICstCj4gIDIg ZmlsZXMgY2hhbmdlZCwgMTk3IGluc2VydGlvbnMoKykKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfZGwuYyBpbmRleCAyZmZmZTk3N2FhMzUuLmQ1YjNjMjRkMTYwYwo+IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiArKysgYi9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jCj4gQEAgLTE0MSw2ICsxNDEsMzAg QEAgc3RydWN0IHZzcDFfZGxfYm9keV9wb29sIHsKPiAgfTsKPiAKPiAgLyoqCj4gKyAqIHN0cnVj dCB2c3AxX2NtZF9wb29sIC0gRGlzcGxheSBMaXN0IGNvbW1hbmRzIHBvb2wKPiArICogQGRtYTog RE1BIGFkZHJlc3Mgb2YgdGhlIGVudHJpZXMKPiArICogQHNpemU6IHNpemUgb2YgdGhlIGZ1bGwg RE1BIG1lbW9yeSBwb29sIGluIGJ5dGVzCj4gKyAqIEBtZW06IENQVSBtZW1vcnkgcG9pbnRlciBm b3IgdGhlIHBvb2wKPiArICogQGNtZHM6IEFycmF5IG9mIGNvbW1hbmQgc3RydWN0dXJlcyBmb3Ig dGhlIHBvb2wKPiArICogQGZyZWU6IEZyZWUgcG9vbCBlbnRyaWVzCj4gKyAqIEBsb2NrOiBQcm90 ZWN0cyB0aGUgZnJlZSBsaXN0Cj4gKyAqIEB2c3AxOiB0aGUgVlNQMSBkZXZpY2UKPiArICovCj4g K3N0cnVjdCB2c3AxX2RsX2NtZF9wb29sIHsKPiArCS8qIERNQSBhbGxvY2F0aW9uICovCj4gKwlk bWFfYWRkcl90IGRtYTsKPiArCXNpemVfdCBzaXplOwo+ICsJdm9pZCAqbWVtOwo+ICsKPiArCXN0 cnVjdCB2c3AxX2RsX2V4dF9jbWQgKmNtZHM7Cj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIGZyZWU7Cj4g Kwo+ICsJc3BpbmxvY2tfdCBsb2NrOwo+ICsKPiArCXN0cnVjdCB2c3AxX2RldmljZSAqdnNwMTsK PiArfTsKPiArCj4gKy8qKgo+ICAgKiBzdHJ1Y3QgdnNwMV9kbF9saXN0IC0gRGlzcGxheSBsaXN0 Cj4gICAqIEBsaXN0OiBlbnRyeSBpbiB0aGUgZGlzcGxheSBsaXN0IG1hbmFnZXIgbGlzdHMKPiAg ICogQGRsbTogdGhlIGRpc3BsYXkgbGlzdCBtYW5hZ2VyCj4gQEAgLTE4Niw2ICsyMTAsNyBAQCBz dHJ1Y3QgdnNwMV9kbF9saXN0IHsKPiAgICogQHF1ZXVlZDogbGlzdCBxdWV1ZWQgdG8gdGhlIGhh cmR3YXJlICh3cml0dGVuIHRvIHRoZSBETCByZWdpc3RlcnMpCj4gICAqIEBwZW5kaW5nOiBsaXN0 IHdhaXRpbmcgdG8gYmUgcXVldWVkIHRvIHRoZSBoYXJkd2FyZQo+ICAgKiBAcG9vbDogYm9keSBw b29sIGZvciB0aGUgZGlzcGxheSBsaXN0IGJvZGllcwo+ICsgKiBAYXV0b2ZsZF9jbWRzOiBjb21t YW5kIHBvb2wgdG8gc3VwcG9ydCBhdXRvLWZsZCBpbnRlcmxhY2VkIG1vZGUKPiAgICovCj4gIHN0 cnVjdCB2c3AxX2RsX21hbmFnZXIgewo+ICAJdW5zaWduZWQgaW50IGluZGV4Owo+IEBAIC0xOTks NiArMjI0LDcgQEAgc3RydWN0IHZzcDFfZGxfbWFuYWdlciB7Cj4gIAlzdHJ1Y3QgdnNwMV9kbF9s aXN0ICpwZW5kaW5nOwo+IAo+ICAJc3RydWN0IHZzcDFfZGxfYm9keV9wb29sICpwb29sOwo+ICsJ c3RydWN0IHZzcDFfZGxfY21kX3Bvb2wgKmNtZHBvb2w7Cj4gIH07Cj4gCj4gIC8qCj4gLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tCj4gLS0gQEAgLTM2Miw2ICszODgsMTU3IEBAIHZvaWQgdnNwMV9kbF9ib2R5 X3dyaXRlKHN0cnVjdCB2c3AxX2RsX2JvZHkgKmRsYiwKPiB1MzIgcmVnLCB1MzIgZGF0YSkgfQo+ IAo+ICAvKgo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IC0tICsgKiBEaXNwbGF5IExpc3QgRXh0ZW5k ZWQgQ29tbWFuZCBNYW5hZ2VtZW50Cj4gKyAqLwo+ICsKPiArZW51bSB2c3AxX2V4dGNtZF90eXBl IHsKPiArCVZTUDFfRVhUQ01EX0FVVE9ESVNQLAo+ICsJVlNQMV9FWFRDTURfQVVUT0ZMRCwKPiAr fTsKPiArCj4gK3N0cnVjdCB2c3AxX2V4dGVuZGVkX2NvbW1hbmRfaW5mbyB7Cj4gKwl1MTYgb3Bj b2RlOwo+ICsJc2l6ZV90IGJvZHlfc2l6ZTsKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgdnNwMV9leHRlbmRlZF9jb21tYW5kX2luZm8gdnNwMV9leHRlbmRlZF9jb21tYW5kc1tdID0g ewo+ICsJW1ZTUDFfRVhUQ01EX0FVVE9ESVNQXSA9IHsgMHgwMiwgOTYgfSwKPiArCVtWU1AxX0VY VENNRF9BVVRPRkxEXSAgPSB7IDB4MDMsIDE2MCB9LAo+ICt9Owo+ICsKPiArLyoqCj4gKyAqIHZz cDFfZGxfY21kX3Bvb2xfY3JlYXRlIC0gQ3JlYXRlIGEgcG9vbCBvZiBjb21tYW5kcyBmcm9tIGEg c2luZ2xlCj4gYWxsb2NhdGlvbiArICogQHZzcDE6IFRoZSBWU1AxIGRldmljZQo+ICsgKiBAdHlw ZTogVGhlIGNvbW1hbmQgcG9vbCB0eXBlCj4gKyAqIEBudW1fY21kczogVGhlIG51bWJlciBvZiBj b21tYW5kcyB0byBhbGxvY2F0ZQo+ICsgKgo+ICsgKiBBbGxvY2F0ZSBhIHBvb2wgb2YgY29tbWFu ZHMgZWFjaCB3aXRoIGVub3VnaCBtZW1vcnkgdG8gY29udGFpbiB0aGUKPiBwcml2YXRlICsgKiBk YXRhIG9mIGVhY2ggY29tbWFuZC4gVGhlIGFsbG9jYXRpb24gc2l6ZXMgYXJlIGRlcGVuZGVudCB1 cG9uCj4gdGhlIGNvbW1hbmQgKyAqIHR5cGUuCj4gKyAqCj4gKyAqIFJldHVybiBhIHBvaW50ZXIg dG8gdGhlIHBvb2wgb24gc3VjY2VzcyBvciBOVUxMIGlmIG1lbW9yeSBjYW4ndCBiZQo+IGFsbG9j YXRlZC4gKyAqLwo+ICtzdGF0aWMgc3RydWN0IHZzcDFfZGxfY21kX3Bvb2wgKgo+ICt2c3AxX2Rs X2NtZF9wb29sX2NyZWF0ZShzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEsIGVudW0gdnNwMV9leHRj bWRfdHlwZQo+IHR5cGUsICsJCQl1bnNpZ25lZCBpbnQgbnVtX2NtZHMpCj4gK3sKPiArCXN0cnVj dCB2c3AxX2RsX2NtZF9wb29sICpwb29sOwo+ICsJdW5zaWduZWQgaW50IGk7Cj4gKwlzaXplX3Qg Y21kX3NpemU7Cj4gKwo+ICsJcG9vbCA9IGt6YWxsb2Moc2l6ZW9mKCpwb29sKSwgR0ZQX0tFUk5F TCk7Cj4gKwlpZiAoIXBvb2wpCj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJc3Bpbl9sb2NrX2lu aXQoJnBvb2wtPmxvY2spOwo+ICsJSU5JVF9MSVNUX0hFQUQoJnBvb2wtPmZyZWUpOwo+ICsKPiAr CXBvb2wtPmNtZHMgPSBrY2FsbG9jKG51bV9jbWRzLCBzaXplb2YoKnBvb2wtPmNtZHMpLCBHRlBf S0VSTkVMKTsKPiArCWlmICghcG9vbC0+Y21kcykgewo+ICsJCWtmcmVlKHBvb2wpOwo+ICsJCXJl dHVybiBOVUxMOwo+ICsJfQo+ICsKPiArCWNtZF9zaXplID0gc2l6ZW9mKHN0cnVjdCB2c3AxX3By ZV9leHRfZGxfYm9keSkgKwo+ICsJCSAgIHZzcDFfZXh0ZW5kZWRfY29tbWFuZHNbdHlwZV0uYm9k eV9zaXplOwo+ICsJY21kX3NpemUgPSBBTElHTihjbWRfc2l6ZSwgMTYpOwo+ICsKPiArCXBvb2wt PnNpemUgPSBjbWRfc2l6ZSAqIG51bV9jbWRzOwo+ICsJcG9vbC0+bWVtID0gZG1hX2FsbG9jX3dj KHZzcDEtPmJ1c19tYXN0ZXIsIHBvb2wtPnNpemUsICZwb29sLT5kbWEsCj4gKwkJCQkgR0ZQX0tF Uk5FTCk7Cj4gKwlpZiAoIXBvb2wtPm1lbSkgewo+ICsJCWtmcmVlKHBvb2wtPmNtZHMpOwo+ICsJ CWtmcmVlKHBvb2wpOwo+ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsKPiArCWZvciAoaSA9IDA7 IGkgPCBudW1fY21kczsgKytpKSB7Cj4gKwkJc3RydWN0IHZzcDFfZGxfZXh0X2NtZCAqY21kID0g JnBvb2wtPmNtZHNbaV07Cj4gKwkJc2l6ZV90IGNtZF9vZmZzZXQgPSBpICogY21kX3NpemU7Cj4g KwkJLyogZGF0YV9vZmZzZXQgbXVzdCBiZSAxNiBieXRlIGFsaWduZWQgZm9yIERNQS4gKi8KPiAr CQlzaXplX3QgZGF0YV9vZmZzZXQgPSBzaXplb2Yoc3RydWN0IHZzcDFfcHJlX2V4dF9kbF9ib2R5 KSArCj4gKwkJCQkgICAgIGNtZF9vZmZzZXQ7Cj4gKwo+ICsJCWNtZC0+cG9vbCA9IHBvb2w7Cj4g KwkJY21kLT5vcGNvZGUgPSB2c3AxX2V4dGVuZGVkX2NvbW1hbmRzW3R5cGVdLm9wY29kZTsKPiAr Cj4gKwkJLyoKPiArCQkgKiBUT0RPOiBBdXRvLWRpc3AgY2FuIHV0aWxpc2UgbW9yZSB0aGFuIG9u ZSBleHRlbmRlZCBib2R5Cj4gKwkJICogY29tbWFuZCBwZXIgY21kLgo+ICsJCSAqLwo+ICsJCWNt ZC0+bnVtX2NtZHMgPSAxOwo+ICsJCWNtZC0+Y21kcyA9IHBvb2wtPm1lbSArIGNtZF9vZmZzZXQ7 Cj4gKwkJY21kLT5jbWRfZG1hID0gcG9vbC0+ZG1hICsgY21kX29mZnNldDsKPiArCj4gKwkJY21k LT5kYXRhID0gcG9vbC0+bWVtICsgZGF0YV9vZmZzZXQ7Cj4gKwkJY21kLT5kYXRhX2RtYSA9IHBv b2wtPmRtYSArIGRhdGFfb2Zmc2V0Owo+ICsKPiArCQlsaXN0X2FkZF90YWlsKCZjbWQtPmZyZWUs ICZwb29sLT5mcmVlKTsKPiArCX0KPiArCj4gKwlyZXR1cm4gcG9vbDsKPiArfQo+ICsKPiArc3Rh dGljCj4gK3N0cnVjdCB2c3AxX2RsX2V4dF9jbWQgKnZzcDFfZGxfZXh0X2NtZF9nZXQoc3RydWN0 IHZzcDFfZGxfY21kX3Bvb2wgKnBvb2wpCj4gK3sKPiArCXN0cnVjdCB2c3AxX2RsX2V4dF9jbWQg KmNtZCA9IE5VTEw7Cj4gKwl1bnNpZ25lZCBsb25nIGZsYWdzOwo+ICsKPiArCXNwaW5fbG9ja19p cnFzYXZlKCZwb29sLT5sb2NrLCBmbGFncyk7Cj4gKwo+ICsJaWYgKCFsaXN0X2VtcHR5KCZwb29s LT5mcmVlKSkgewo+ICsJCWNtZCA9IGxpc3RfZmlyc3RfZW50cnkoJnBvb2wtPmZyZWUsIHN0cnVj dCB2c3AxX2RsX2V4dF9jbWQsCj4gKwkJCQkgICAgICAgZnJlZSk7Cj4gKwkJbGlzdF9kZWwoJmNt ZC0+ZnJlZSk7Cj4gKwl9Cj4gKwo+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9vbC0+bG9j aywgZmxhZ3MpOwo+ICsKPiArCXJldHVybiBjbWQ7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZz cDFfZGxfZXh0X2NtZF9wdXQoc3RydWN0IHZzcDFfZGxfZXh0X2NtZCAqY21kKQo+ICt7Cj4gKwl1 bnNpZ25lZCBsb25nIGZsYWdzOwo+ICsKPiArCWlmICghY21kKQo+ICsJCXJldHVybjsKPiArCj4g KwkvKiBSZXNldCBmbGFncywgdGhlc2UgbWFyayBkYXRhIHVzYWdlLiAqLwo+ICsJY21kLT5mbGFn cyA9IDA7Cj4gKwo+ICsJc3Bpbl9sb2NrX2lycXNhdmUoJmNtZC0+cG9vbC0+bG9jaywgZmxhZ3Mp Owo+ICsJbGlzdF9hZGRfdGFpbCgmY21kLT5mcmVlLCAmY21kLT5wb29sLT5mcmVlKTsKPiArCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmNtZC0+cG9vbC0+bG9jaywgZmxhZ3MpOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgdm9pZCB2c3AxX2RsX2V4dF9jbWRfcG9vbF9kZXN0cm95KHN0cnVjdCB2c3AxX2Rs X2NtZF9wb29sICpwb29sKQo+ICt7Cj4gKwlpZiAoIXBvb2wpCj4gKwkJcmV0dXJuOwo+ICsKPiAr CWlmIChwb29sLT5tZW0pCj4gKwkJZG1hX2ZyZWVfd2MocG9vbC0+dnNwMS0+YnVzX21hc3Rlciwg cG9vbC0+c2l6ZSwgcG9vbC0+bWVtLAo+ICsJCQkgICAgcG9vbC0+ZG1hKTsKPiArCj4gKwlrZnJl ZShwb29sLT5jbWRzKTsKPiArCWtmcmVlKHBvb2wpOwo+ICt9Cj4gKwo+ICtzdHJ1Y3QgdnNwMV9k bF9leHRfY21kICp2c3AxX2RsX2dldF9wcmVfY21kKHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsKQo+ ICt7Cj4gKwlzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0gPSBkbC0+ZGxtOwo+ICsKPiArCWlm IChkbC0+cHJlX2NtZCkKPiArCQlyZXR1cm4gZGwtPnByZV9jbWQ7Cj4gKwo+ICsJZGwtPnByZV9j bWQgPSB2c3AxX2RsX2V4dF9jbWRfZ2V0KGRsbS0+Y21kcG9vbCk7Cj4gKwo+ICsJcmV0dXJuIGRs LT5wcmVfY21kOwo+ICt9Cj4gKwo+ICsvKgo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IC0gKiBEaXNw bGF5IExpc3QgVHJhbnNhY3Rpb24gTWFuYWdlbWVudAo+ICAgKi8KPiAKPiBAQCAtNDYzLDYgKzY0 MCwxMiBAQCBzdGF0aWMgdm9pZCBfX3ZzcDFfZGxfbGlzdF9wdXQoc3RydWN0IHZzcDFfZGxfbGlz dCAqZGwpCj4gCj4gIAl2c3AxX2RsX2xpc3RfYm9kaWVzX3B1dChkbCk7Cj4gCj4gKwl2c3AxX2Rs X2V4dF9jbWRfcHV0KGRsLT5wcmVfY21kKTsKPiArCXZzcDFfZGxfZXh0X2NtZF9wdXQoZGwtPnBv c3RfY21kKTsKPiArCj4gKwlkbC0+cHJlX2NtZCA9IE5VTEw7Cj4gKwlkbC0+cG9zdF9jbWQgPSBO VUxMOwo+ICsKPiAgCS8qCj4gIAkgKiBib2R5MCBpcyByZXVzZWQgYXMgYXMgYW4gb3B0aW1pc2F0 aW9uIGFzIHByZXNlbnRseSBldmVyeSBkaXNwbGF5IGxpc3QKPiAgCSAqIGhhcyBhdCBsZWFzdCBv bmUgYm9keSwgdGh1cyB3ZSByZWluaXRpYWxpc2UgdGhlIGVudHJpZXMgbGlzdC4KPiBAQCAtOTEz LDYgKzEwOTYsMTUgQEAgc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqdnNwMV9kbG1fY3JlYXRlKHN0 cnVjdAo+IHZzcDFfZGV2aWNlICp2c3AxLCBsaXN0X2FkZF90YWlsKCZkbC0+bGlzdCwgJmRsbS0+ ZnJlZSk7Cj4gIAl9Cj4gCj4gKwlpZiAodnNwMV9mZWF0dXJlKHZzcDEsIFZTUDFfSEFTX0VYVF9E TCkpIHsKPiArCQlkbG0tPmNtZHBvb2wgPSB2c3AxX2RsX2NtZF9wb29sX2NyZWF0ZSh2c3AxLAo+ ICsJCQkJCVZTUDFfRVhUQ01EX0FVVE9GTEQsIHByZWFsbG9jKTsKPiArCQlpZiAoIWRsbS0+Y21k cG9vbCkgewo+ICsJCQl2c3AxX2RsbV9kZXN0cm95KGRsbSk7Cj4gKwkJCXJldHVybiBOVUxMOwo+ ICsJCX0KPiArCX0KPiArCj4gIAlyZXR1cm4gZGxtOwo+ICB9Cj4gCj4gQEAgLTkyOSw0ICsxMTIx LDYgQEAgdm9pZCB2c3AxX2RsbV9kZXN0cm95KHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKmRsbSkK PiAgCX0KPiAKPiAgCXZzcDFfZGxfYm9keV9wb29sX2Rlc3Ryb3koZGxtLT5wb29sKTsKPiArCXZz cDFfZGxfZXh0X2NtZF9wb29sX2Rlc3Ryb3koZGxtLT5jbWRwb29sKTsKPiAgfQo+ICsKCkV4dHJh IGJsYW5rIGxpbmUuIEFwYXJ0IGZyb20gdGhhdCwKClJldmlld2VkLWJ5OiBMYXVyZW50IFBpbmNo YXJ0IDxsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25ib2FyZC5jb20+Cgo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oCj4gYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3ZzcDEvdnNwMV9kbC5oIGluZGV4IGFmZWZkNWJmYTEzNi4uMTI1NzUwZGM4YjVjCj4g MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuaAo+ICsr KyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmgKPiBAQCAtMjIsNiArMjIs NyBAQCBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyOwo+IAo+ICAvKioKPiAgICogc3RydWN0IHZzcDFf ZGxfZXh0X2NtZCAtIEV4dGVuZGVkIERpc3BsYXkgY29tbWFuZAo+ICsgKiBAcG9vbDogcG9vbCB0 byB3aGljaCB0aGlzIGNvbW1hbmQgYmVsb25ncwo+ICAgKiBAZnJlZTogZW50cnkgaW4gdGhlIHBv b2wgb2YgZnJlZSBjb21tYW5kcyBsaXN0Cj4gICAqIEBvcGNvZGU6IGNvbW1hbmQgdHlwZSBvcGNv ZGUKPiAgICogQGZsYWdzOiBmbGFncyB1c2VkIGJ5IHRoZSBjb21tYW5kCj4gQEAgLTMyLDYgKzMz LDcgQEAgc3RydWN0IHZzcDFfZGxfbWFuYWdlcjsKPiAgICogQGRhdGFfZG1hOiBETUEgYWRkcmVz cyBmb3IgY29tbWFuZC1zcGVjaWZpYyBkYXRhCj4gICAqLwo+ICBzdHJ1Y3QgdnNwMV9kbF9leHRf Y21kIHsKPiArCXN0cnVjdCB2c3AxX2RsX2NtZF9wb29sICpwb29sOwo+ICAJc3RydWN0IGxpc3Rf aGVhZCBmcmVlOwo+IAo+ICAJdTggb3Bjb2RlOwo+IEBAIC01OCw2ICs2MCw3IEBAIHN0cnVjdCB2 c3AxX2RsX2JvZHkgKnZzcDFfZGxtX2RsX2JvZHlfZ2V0KHN0cnVjdAo+IHZzcDFfZGxfbWFuYWdl ciAqZGxtKTsgc3RydWN0IHZzcDFfZGxfbGlzdCAqdnNwMV9kbF9saXN0X2dldChzdHJ1Y3QKPiB2 c3AxX2RsX21hbmFnZXIgKmRsbSk7IHZvaWQgdnNwMV9kbF9saXN0X3B1dChzdHJ1Y3QgdnNwMV9k bF9saXN0ICpkbCk7Cj4gIHN0cnVjdCB2c3AxX2RsX2JvZHkgKnZzcDFfZGxfbGlzdF9nZXRfYm9k eTAoc3RydWN0IHZzcDFfZGxfbGlzdCAqZGwpOwo+ICtzdHJ1Y3QgdnNwMV9kbF9leHRfY21kICp2 c3AxX2RsX2dldF9wcmVfY21kKHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsKTsKPiAgdm9pZCB2c3Ax X2RsX2xpc3RfY29tbWl0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBib29sIGludGVybmFsKTsK PiAKPiAgc3RydWN0IHZzcDFfZGxfYm9keV9wb29sICoKCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQ aW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK