From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:45298 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966400AbeEXMMy (ORCPT ); Thu, 24 May 2018 08:12:54 -0400 From: Laurent Pinchart To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [PATCH v4 09/11] media: vsp1: Provide support for extended command pools Date: Thu, 24 May 2018 15:12:50 +0300 Message-ID: <3571558.kvhfykCuCL@avalon> In-Reply-To: <58cdbb43c0d617e28b3545060aff2019d42c148c.1525354194.git-series.kieran.bingham+renesas@ideasonboard.com> References: <58cdbb43c0d617e28b3545060aff2019d42c148c.1525354194.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 Thursday, 3 May 2018 16:36:20 EEST Kieran Bingham wrote: > 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) > --- > drivers/media/platform/vsp1/vsp1_dl.c | 191 +++++++++++++++++++++++++++- > drivers/media/platform/vsp1/vsp1_dl.h | 3 +- > 2 files changed, 194 insertions(+) > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > b/drivers/media/platform/vsp1/vsp1_dl.c index b64d32535edc..d33ae5f125bd > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.c > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > @@ -117,6 +117,30 @@ struct vsp1_dl_body_pool { > }; > > /** > + * struct vsp1_cmd_pool - display list body pool The structure is called vsp1_dl_cmd_pool. I would document it as "Display list commands pool", not "body pool". > + * @dma: DMA address of the entries > + * @size: size of the full DMA memory pool in bytes > + * @mem: CPU memory pointer for the pool > + * @bodies: Array of DLB structures for the pool The field is called cmds. > + * @free: List of free DLB entries "free pool entries" or "free command entries" ? > + * @lock: Protects the pool and free list The pool is the whole structure, does the lock really protects all fields ? > + * @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 > @@ -162,6 +186,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 This could also be used for auto-disp. How about calling it cmdpool ? > */ > struct vsp1_dl_manager { > unsigned int index; > @@ -175,6 +200,7 @@ struct vsp1_dl_manager { > struct vsp1_dl_list *pending; > > struct vsp1_dl_body_pool *pool; > + struct vsp1_dl_cmd_pool *autofld_cmds; > }; > > /* ------------------------------------------------------------------------ > @@ -338,6 +364,140 @@ 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 vsp1_extended_commands[] = { The location of the static const keywords is strange. I would move them before struct, or split the structure definition and variable declaration. > + [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_commands: The quantity of commands to allocate s/quantity/number/ ? > + * > + * 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 a pool on success or NULL if memory can't be s/a pool/the pool/ > 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; > + > + pool->cmds = kcalloc(num_cmds, sizeof(*pool->cmds), GFP_KERNEL); > + if (!pool->cmds) { > + kfree(pool); > + return NULL; > + } > + > + cmd_size = sizeof(struct vsp1_dl_ext_cmd_header) + > + 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; > + } > + > + spin_lock_init(&pool->lock); > + INIT_LIST_HEAD(&pool->free); I would move these two lines right after allocation of pool, I find it more readable to perform small and simple initialization right away. > + for (i = 0; i < num_cmds; ++i) { > + struct vsp1_dl_ext_cmd *cmd = &pool->cmds[i]; > + size_t cmd_offset = i * cmd_size; > + size_t data_offset = sizeof(struct vsp1_dl_ext_cmd_header) + > + cmd_offset; The data memory has to be 16-bytes aligned. This is guaranteed as the header is 16 bytes long, and cmd_size is aligned to 16 bytes, but it would be worth adding a comment to explain this. > + cmd->pool = pool; > + cmd->cmd_opcode = vsp1_extended_commands[type].opcode; > + > + /* TODO: Auto-disp can utilise more than one command per cmd */ That will be annoying to handle :-/ > + 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; > + cmd->data_size = vsp1_extended_commands[type].body_size; > + > + 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 */ s/usage/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); > +} > + > +/* ------------------------------------------------------------------------ > - * Display List Transaction Management > */ > > @@ -440,6 +600,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. > @@ -883,6 +1049,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->autofld_cmds = vsp1_dl_cmd_pool_create(vsp1, > + VSP1_EXTCMD_AUTOFLD, prealloc); > + if (!dlm->autofld_cmds) { > + vsp1_dlm_destroy(dlm); > + return NULL; > + } > + } > + > return dlm; > } > > @@ -899,4 +1074,20 @@ void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm) > } > > vsp1_dl_body_pool_destroy(dlm->pool); > + vsp1_dl_ext_cmd_pool_destroy(dlm->autofld_cmds); > +} > + > +struct vsp1_dl_ext_cmd *vsp1_dlm_get_autofld_cmd(struct vsp1_dl_list *dl) > +{ > + struct vsp1_dl_manager *dlm = dl->dlm; > + struct vsp1_dl_ext_cmd *cmd; > + > + if (dl->pre_cmd) > + return dl->pre_cmd; > + > + cmd = vsp1_dl_ext_cmd_get(dlm->autofld_cmds); > + if (cmd) > + dl->pre_cmd = cmd; > + > + return cmd; You can write it in a simpler way. dl->pre_cmd = vsp1_dl_ext_cmd_get(dlm->autofld_cmds); return dl->pre_cmd; > } > diff --git a/drivers/media/platform/vsp1/vsp1_dl.h > b/drivers/media/platform/vsp1/vsp1_dl.h index aa5f4adc6617..d9621207b093 > 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 > * @cmd_opcode: command type opcode > * @flags: flags used by the command > @@ -33,6 +34,7 @@ struct vsp1_dl_manager; > * @data_size: size of the @data_dma memory in bytes > */ > struct vsp1_dl_ext_cmd { > + struct vsp1_dl_cmd_pool *pool; > struct list_head free; > > u8 cmd_opcode; > @@ -55,6 +57,7 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device > *vsp1, void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm); > void vsp1_dlm_reset(struct vsp1_dl_manager *dlm); > unsigned int vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm); > +struct vsp1_dl_ext_cmd *vsp1_dlm_get_autofld_cmd(struct vsp1_dl_list *dl); Should this be named vsp1_dl_get_autofld_cmd() as it operates on a dl ? I also think that you should move it down to group it with the dl functions. > struct vsp1_dl_list *vsp1_dl_list_get(struct vsp1_dl_manager *dlm); > void vsp1_dl_list_put(struct vsp1_dl_list *dl); -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v4 09/11] media: vsp1: Provide support for extended command pools Date: Thu, 24 May 2018 15:12:50 +0300 Message-ID: <3571558.kvhfykCuCL@avalon> References: <58cdbb43c0d617e28b3545060aff2019d42c148c.1525354194.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 DC84D6E010 for ; Thu, 24 May 2018 12:12:54 +0000 (UTC) In-Reply-To: <58cdbb43c0d617e28b3545060aff2019d42c148c.1525354194.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, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBUaHVyc2RheSwgMyBNYXkg MjAxOCAxNjozNjoyMCBFRVNUIEtpZXJhbiBCaW5naGFtIHdyb3RlOgo+IFZTUEQgYW5kIFZTUC1E TCBkZXZpY2VzIGNhbiBwcm92aWRlIGV4dGVuZGVkIGRpc3BsYXkgbGlzdHMgc3VwcG9ydGluZwo+ IGV4dGVuZGVkIGNvbW1hbmQgZGlzcGxheSBsaXN0IG9iamVjdHMuCj4gCj4gVGhlc2UgZXh0ZW5k ZWQgY29tbWFuZHMgcmVxdWlyZSB0aGVpciBvd24gZG1hIG1lbW9yeSBhcmVhcyBmb3IgYSBoZWFk ZXIKPiBhbmQgYm9keSBzcGVjaWZpYyB0byB0aGUgY29tbWFuZCB0eXBlLgo+IAo+IEltcGxlbWVu dCBhIGNvbW1hbmQgcG9vbCB0byBhbGxvY2F0ZSBhbGwgbmVjZXNzYXJ5IG1lbW9yeSBpbiBhIHNp bmdsZQo+IERNQSBhbGxvY2F0aW9uIHRvIHJlZHVjZSBwcmVzc3VyZSBvbiB0aGUgVExCLCBhbmQg cHJvdmlkZSBjb252ZW5pZW50Cj4gcmUtdXNhYmxlIGNvbW1hbmQgb2JqZWN0cyBmb3IgdGhlIGVu dGl0aWVzIHRvIHV0aWxpc2UuCj4gCj4gU2lnbmVkLW9mZi1ieTogS2llcmFuIEJpbmdoYW0gPGtp ZXJhbi5iaW5naGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAKPiAtLS0KPiAKPiB2MjoK PiAgLSBGaXggc3BlbGxpbmcgdHlwbyBpbiBjb21taXQgbWVzc2FnZQo+ICAtIGNvbnN0aWZ5LCBh bmQgc3RhdGljaWZ5IHRoZSBpbnN0YW50aWF0aW9uIG9mIHZzcDFfZXh0ZW5kZWRfY29tbWFuZHMK PiAgLSBzL2F1dGZsZF9jbWRzL2F1dG9mbGRfY21kcy8KPiAgLSBzdGF0aWNpZnkgY21kIHBvb2wg ZnVuY3Rpb25zIChUaGFua3Mga2J1aWxkLWJvdCkKPiAtLS0KPiAgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZGwuYyB8IDE5MSArKysrKysrKysrKysrKysrKysrKysrKysrKystCj4g IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmggfCAgIDMgKy0KPiAgMiBmaWxl cyBjaGFuZ2VkLCAxOTQgaW5zZXJ0aW9ucygrKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jCj4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kbC5jIGluZGV4IGI2NGQzMjUzNWVkYy4uZDMzYWU1ZjEyNWJkCj4gMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ICsrKyBiL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiBAQCAtMTE3LDYgKzExNywzMCBAQCBz dHJ1Y3QgdnNwMV9kbF9ib2R5X3Bvb2wgewo+ICB9Owo+IAo+ICAvKioKPiArICogc3RydWN0IHZz cDFfY21kX3Bvb2wgLSBkaXNwbGF5IGxpc3QgYm9keSBwb29sCgpUaGUgc3RydWN0dXJlIGlzIGNh bGxlZCB2c3AxX2RsX2NtZF9wb29sLiBJIHdvdWxkIGRvY3VtZW50IGl0IGFzICJEaXNwbGF5IGxp c3QgCmNvbW1hbmRzIHBvb2wiLCBub3QgImJvZHkgcG9vbCIuCgo+ICsgKiBAZG1hOiBETUEgYWRk cmVzcyBvZiB0aGUgZW50cmllcwo+ICsgKiBAc2l6ZTogc2l6ZSBvZiB0aGUgZnVsbCBETUEgbWVt b3J5IHBvb2wgaW4gYnl0ZXMKPiArICogQG1lbTogQ1BVIG1lbW9yeSBwb2ludGVyIGZvciB0aGUg cG9vbAo+ICsgKiBAYm9kaWVzOiBBcnJheSBvZiBETEIgc3RydWN0dXJlcyBmb3IgdGhlIHBvb2wK ClRoZSBmaWVsZCBpcyBjYWxsZWQgY21kcy4KCj4gKyAqIEBmcmVlOiBMaXN0IG9mIGZyZWUgRExC IGVudHJpZXMKCiJmcmVlIHBvb2wgZW50cmllcyIgb3IgImZyZWUgY29tbWFuZCBlbnRyaWVzIiA/ Cgo+ICsgKiBAbG9jazogUHJvdGVjdHMgdGhlIHBvb2wgYW5kIGZyZWUgbGlzdAoKVGhlIHBvb2wg aXMgdGhlIHdob2xlIHN0cnVjdHVyZSwgZG9lcyB0aGUgbG9jayByZWFsbHkgcHJvdGVjdHMgYWxs IGZpZWxkcyA/Cgo+ICsgKiBAdnNwMTogdGhlIFZTUDEgZGV2aWNlCj4gKyAqLwo+ICtzdHJ1Y3Qg dnNwMV9kbF9jbWRfcG9vbCB7Cj4gKwkvKiBETUEgYWxsb2NhdGlvbiAqLwo+ICsJZG1hX2FkZHJf dCBkbWE7Cj4gKwlzaXplX3Qgc2l6ZTsKPiArCXZvaWQgKm1lbTsKPiArCj4gKwlzdHJ1Y3QgdnNw MV9kbF9leHRfY21kICpjbWRzOwo+ICsJc3RydWN0IGxpc3RfaGVhZCBmcmVlOwo+ICsKPiArCXNw aW5sb2NrX3QgbG9jazsKPiArCj4gKwlzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDE7Cj4gK307Cj4g Kwo+ICsvKioKPiAgICogc3RydWN0IHZzcDFfZGxfbGlzdCAtIERpc3BsYXkgbGlzdAo+ICAgKiBA bGlzdDogZW50cnkgaW4gdGhlIGRpc3BsYXkgbGlzdCBtYW5hZ2VyIGxpc3RzCj4gICAqIEBkbG06 IHRoZSBkaXNwbGF5IGxpc3QgbWFuYWdlcgo+IEBAIC0xNjIsNiArMTg2LDcgQEAgc3RydWN0IHZz cDFfZGxfbGlzdCB7Cj4gICAqIEBxdWV1ZWQ6IGxpc3QgcXVldWVkIHRvIHRoZSBoYXJkd2FyZSAo d3JpdHRlbiB0byB0aGUgREwgcmVnaXN0ZXJzKQo+ICAgKiBAcGVuZGluZzogbGlzdCB3YWl0aW5n IHRvIGJlIHF1ZXVlZCB0byB0aGUgaGFyZHdhcmUKPiAgICogQHBvb2w6IGJvZHkgcG9vbCBmb3Ig dGhlIGRpc3BsYXkgbGlzdCBib2RpZXMKPiArICogQGF1dG9mbGRfY21kczogY29tbWFuZCBwb29s IHRvIHN1cHBvcnQgYXV0by1mbGQgaW50ZXJsYWNlZCBtb2RlCgpUaGlzIGNvdWxkIGFsc28gYmUg dXNlZCBmb3IgYXV0by1kaXNwLiBIb3cgYWJvdXQgY2FsbGluZyBpdCBjbWRwb29sID8KCj4gICAq Lwo+ICBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyIHsKPiAgCXVuc2lnbmVkIGludCBpbmRleDsKPiBA QCAtMTc1LDYgKzIwMCw3IEBAIHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgewo+ICAJc3RydWN0IHZz cDFfZGxfbGlzdCAqcGVuZGluZzsKPiAKPiAgCXN0cnVjdCB2c3AxX2RsX2JvZHlfcG9vbCAqcG9v bDsKPiArCXN0cnVjdCB2c3AxX2RsX2NtZF9wb29sICphdXRvZmxkX2NtZHM7Cj4gIH07Cj4gCj4g IC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQo+IEBAIC0zMzgsNiArMzY0LDE0MCBAQCB2b2lkIHZzcDFfZGxf Ym9keV93cml0ZShzdHJ1Y3QgdnNwMV9kbF9ib2R5ICpkbGIsCj4gdTMyIHJlZywgdTMyIGRhdGEp IH0KPiAKPiAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gKyAqIERpc3BsYXkgTGlzdCBFeHRlbmRlZCBD b21tYW5kIE1hbmFnZW1lbnQKPiArICovCj4gKwo+ICtlbnVtIHZzcDFfZXh0Y21kX3R5cGUgewo+ ICsJVlNQMV9FWFRDTURfQVVUT0RJU1AsCj4gKwlWU1AxX0VYVENNRF9BVVRPRkxELAo+ICt9Owo+ ICsKPiArc3RydWN0IHZzcDFfZXh0ZW5kZWRfY29tbWFuZF9pbmZvIHsKPiArCXUxNiBvcGNvZGU7 Cj4gKwlzaXplX3QgYm9keV9zaXplOwo+ICt9IHN0YXRpYyBjb25zdCB2c3AxX2V4dGVuZGVkX2Nv bW1hbmRzW10gPSB7CgpUaGUgbG9jYXRpb24gb2YgdGhlIHN0YXRpYyBjb25zdCBrZXl3b3JkcyBp cyBzdHJhbmdlLiBJIHdvdWxkIG1vdmUgdGhlbSBiZWZvcmUgCnN0cnVjdCwgb3Igc3BsaXQgdGhl IHN0cnVjdHVyZSBkZWZpbml0aW9uIGFuZCB2YXJpYWJsZSBkZWNsYXJhdGlvbi4KCj4gKwlbVlNQ MV9FWFRDTURfQVVUT0RJU1BdID0geyAweDAyLCA5NiB9LAo+ICsJW1ZTUDFfRVhUQ01EX0FVVE9G TERdICA9IHsgMHgwMywgMTYwIH0sCj4gK307Cj4gKwo+ICsvKioKPiArICogdnNwMV9kbF9jbWRf cG9vbF9jcmVhdGUgLSBDcmVhdGUgYSBwb29sIG9mIGNvbW1hbmRzIGZyb20gYSBzaW5nbGUKPiBh bGxvY2F0aW9uCj4gKyAqIEB2c3AxOiBUaGUgVlNQMSBkZXZpY2UKPiArICogQHR5cGU6IFRoZSBj b21tYW5kIHBvb2wgdHlwZQo+ICsgKiBAbnVtX2NvbW1hbmRzOiBUaGUgcXVhbnRpdHkgb2YgY29t bWFuZHMgdG8gYWxsb2NhdGUKCnMvcXVhbnRpdHkvbnVtYmVyLyA/Cgo+ICsgKgo+ICsgKiBBbGxv Y2F0ZSBhIHBvb2wgb2YgY29tbWFuZHMgZWFjaCB3aXRoIGVub3VnaCBtZW1vcnkgdG8gY29udGFp biB0aGUKPiBwcml2YXRlCj4gKyAqIGRhdGEgb2YgZWFjaCBjb21tYW5kLiBUaGUgYWxsb2NhdGlv biBzaXplcyBhcmUgZGVwZW5kZW50IHVwb24gdGhlCj4gY29tbWFuZAo+ICsgKiB0eXBlLgo+ICsg Kgo+ICsgKiBSZXR1cm4gYSBwb2ludGVyIHRvIGEgcG9vbCBvbiBzdWNjZXNzIG9yIE5VTEwgaWYg bWVtb3J5IGNhbid0IGJlCgpzL2EgcG9vbC90aGUgcG9vbC8KCj4gYWxsb2NhdGVkLgo+ICsgKi8K PiArc3RhdGljIHN0cnVjdCB2c3AxX2RsX2NtZF9wb29sICoKPiArdnNwMV9kbF9jbWRfcG9vbF9j cmVhdGUoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxLCBlbnVtIHZzcDFfZXh0Y21kX3R5cGUKPiB0 eXBlLAo+ICsJCQl1bnNpZ25lZCBpbnQgbnVtX2NtZHMpCj4gK3sKPiArCXN0cnVjdCB2c3AxX2Rs X2NtZF9wb29sICpwb29sOwo+ICsJdW5zaWduZWQgaW50IGk7Cj4gKwlzaXplX3QgY21kX3NpemU7 Cj4gKwo+ICsJcG9vbCA9IGt6YWxsb2Moc2l6ZW9mKCpwb29sKSwgR0ZQX0tFUk5FTCk7Cj4gKwlp ZiAoIXBvb2wpCj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJcG9vbC0+Y21kcyA9IGtjYWxsb2Mo bnVtX2NtZHMsIHNpemVvZigqcG9vbC0+Y21kcyksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFwb29s LT5jbWRzKSB7Cj4gKwkJa2ZyZWUocG9vbCk7Cj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwl9Cj4gKwo+ ICsJY21kX3NpemUgPSBzaXplb2Yoc3RydWN0IHZzcDFfZGxfZXh0X2NtZF9oZWFkZXIpICsKPiAr CQkgICB2c3AxX2V4dGVuZGVkX2NvbW1hbmRzW3R5cGVdLmJvZHlfc2l6ZTsKPiArCWNtZF9zaXpl ID0gQUxJR04oY21kX3NpemUsIDE2KTsKPiArCj4gKwlwb29sLT5zaXplID0gY21kX3NpemUgKiBu dW1fY21kczsKPiArCXBvb2wtPm1lbSA9IGRtYV9hbGxvY193Yyh2c3AxLT5idXNfbWFzdGVyLCBw b29sLT5zaXplLCAmcG9vbC0+ZG1hLAo+ICsJCQkJIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFwb29s LT5tZW0pIHsKPiArCQlrZnJlZShwb29sLT5jbWRzKTsKPiArCQlrZnJlZShwb29sKTsKPiArCQly ZXR1cm4gTlVMTDsKPiArCX0KPiArCj4gKwlzcGluX2xvY2tfaW5pdCgmcG9vbC0+bG9jayk7Cj4g KwlJTklUX0xJU1RfSEVBRCgmcG9vbC0+ZnJlZSk7CgpJIHdvdWxkIG1vdmUgdGhlc2UgdHdvIGxp bmVzIHJpZ2h0IGFmdGVyIGFsbG9jYXRpb24gb2YgcG9vbCwgSSBmaW5kIGl0IG1vcmUgCnJlYWRh YmxlIHRvIHBlcmZvcm0gc21hbGwgYW5kIHNpbXBsZSBpbml0aWFsaXphdGlvbiByaWdodCBhd2F5 LgoKPiArCWZvciAoaSA9IDA7IGkgPCBudW1fY21kczsgKytpKSB7Cj4gKwkJc3RydWN0IHZzcDFf ZGxfZXh0X2NtZCAqY21kID0gJnBvb2wtPmNtZHNbaV07Cj4gKwkJc2l6ZV90IGNtZF9vZmZzZXQg PSBpICogY21kX3NpemU7Cj4gKwkJc2l6ZV90IGRhdGFfb2Zmc2V0ID0gc2l6ZW9mKHN0cnVjdCB2 c3AxX2RsX2V4dF9jbWRfaGVhZGVyKSArCj4gKwkJCQkgICAgIGNtZF9vZmZzZXQ7CgpUaGUgZGF0 YSBtZW1vcnkgaGFzIHRvIGJlIDE2LWJ5dGVzIGFsaWduZWQuIFRoaXMgaXMgZ3VhcmFudGVlZCBh cyB0aGUgaGVhZGVyIAppcyAxNiBieXRlcyBsb25nLCBhbmQgY21kX3NpemUgaXMgYWxpZ25lZCB0 byAxNiBieXRlcywgYnV0IGl0IHdvdWxkIGJlIHdvcnRoIAphZGRpbmcgYSBjb21tZW50IHRvIGV4 cGxhaW4gdGhpcy4KCj4gKwkJY21kLT5wb29sID0gcG9vbDsKPiArCQljbWQtPmNtZF9vcGNvZGUg PSB2c3AxX2V4dGVuZGVkX2NvbW1hbmRzW3R5cGVdLm9wY29kZTsKPiArCj4gKwkJLyogVE9ETzog QXV0by1kaXNwIGNhbiB1dGlsaXNlIG1vcmUgdGhhbiBvbmUgY29tbWFuZCBwZXIgY21kICovCgpU aGF0IHdpbGwgYmUgYW5ub3lpbmcgdG8gaGFuZGxlIDotLwoKPiArCQljbWQtPm51bV9jbWRzID0g MTsKPiArCQljbWQtPmNtZHMgPSBwb29sLT5tZW0gKyBjbWRfb2Zmc2V0Owo+ICsJCWNtZC0+Y21k X2RtYSA9IHBvb2wtPmRtYSArIGNtZF9vZmZzZXQ7Cj4gKwo+ICsJCWNtZC0+ZGF0YSA9IHBvb2wt Pm1lbSArIGRhdGFfb2Zmc2V0Owo+ICsJCWNtZC0+ZGF0YV9kbWEgPSBwb29sLT5kbWEgKyBkYXRh X29mZnNldDsKPiArCQljbWQtPmRhdGFfc2l6ZSA9IHZzcDFfZXh0ZW5kZWRfY29tbWFuZHNbdHlw ZV0uYm9keV9zaXplOwo+ICsKPiArCQlsaXN0X2FkZF90YWlsKCZjbWQtPmZyZWUsICZwb29sLT5m cmVlKTsKPiArCX0KPiArCj4gKwlyZXR1cm4gcG9vbDsKPiArfQo+ICsKPiArc3RhdGljCj4gK3N0 cnVjdCB2c3AxX2RsX2V4dF9jbWQgKnZzcDFfZGxfZXh0X2NtZF9nZXQoc3RydWN0IHZzcDFfZGxf Y21kX3Bvb2wgKnBvb2wpCj4gK3sKPiArCXN0cnVjdCB2c3AxX2RsX2V4dF9jbWQgKmNtZCA9IE5V TEw7Cj4gKwl1bnNpZ25lZCBsb25nIGZsYWdzOwo+ICsKPiArCXNwaW5fbG9ja19pcnFzYXZlKCZw b29sLT5sb2NrLCBmbGFncyk7Cj4gKwo+ICsJaWYgKCFsaXN0X2VtcHR5KCZwb29sLT5mcmVlKSkg ewo+ICsJCWNtZCA9IGxpc3RfZmlyc3RfZW50cnkoJnBvb2wtPmZyZWUsIHN0cnVjdCB2c3AxX2Rs X2V4dF9jbWQsCj4gKwkJCQkgICAgICAgZnJlZSk7Cj4gKwkJbGlzdF9kZWwoJmNtZC0+ZnJlZSk7 Cj4gKwl9Cj4gKwo+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9vbC0+bG9jaywgZmxhZ3Mp Owo+ICsKPiArCXJldHVybiBjbWQ7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZzcDFfZGxfZXh0 X2NtZF9wdXQoc3RydWN0IHZzcDFfZGxfZXh0X2NtZCAqY21kKQo+ICt7Cj4gKwl1bnNpZ25lZCBs b25nIGZsYWdzOwo+ICsKPiArCWlmICghY21kKQo+ICsJCXJldHVybjsKPiArCj4gKwkvKiBSZXNl dCBmbGFncywgdGhlc2UgbWFyayBkYXRhIHVzYWdlICovCgpzL3VzYWdlL3VzYWdlLi8KCj4gKwlj bWQtPmZsYWdzID0gMDsKPiArCj4gKwlzcGluX2xvY2tfaXJxc2F2ZSgmY21kLT5wb29sLT5sb2Nr LCBmbGFncyk7Cj4gKwlsaXN0X2FkZF90YWlsKCZjbWQtPmZyZWUsICZjbWQtPnBvb2wtPmZyZWUp Owo+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY21kLT5wb29sLT5sb2NrLCBmbGFncyk7Cj4g K30KPiArCj4gK3N0YXRpYyB2b2lkIHZzcDFfZGxfZXh0X2NtZF9wb29sX2Rlc3Ryb3koc3RydWN0 IHZzcDFfZGxfY21kX3Bvb2wgKnBvb2wpCj4gK3sKPiArCWlmICghcG9vbCkKPiArCQlyZXR1cm47 Cj4gKwo+ICsJaWYgKHBvb2wtPm1lbSkKPiArCQlkbWFfZnJlZV93Yyhwb29sLT52c3AxLT5idXNf bWFzdGVyLCBwb29sLT5zaXplLCBwb29sLT5tZW0sCj4gKwkJCSAgICBwb29sLT5kbWEpOwo+ICsK PiArCWtmcmVlKHBvb2wtPmNtZHMpOwo+ICsJa2ZyZWUocG9vbCk7Cj4gK30KPiArCj4gKy8qIC0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQo+IC0gKiBEaXNwbGF5IExpc3QgVHJhbnNhY3Rpb24gTWFuYWdlbWVudAo+ ICAgKi8KPiAKPiBAQCAtNDQwLDYgKzYwMCwxMiBAQCBzdGF0aWMgdm9pZCBfX3ZzcDFfZGxfbGlz dF9wdXQoc3RydWN0IHZzcDFfZGxfbGlzdCAqZGwpCj4gCj4gIAl2c3AxX2RsX2xpc3RfYm9kaWVz X3B1dChkbCk7Cj4gCj4gKwl2c3AxX2RsX2V4dF9jbWRfcHV0KGRsLT5wcmVfY21kKTsKPiArCXZz cDFfZGxfZXh0X2NtZF9wdXQoZGwtPnBvc3RfY21kKTsKPiArCj4gKwlkbC0+cHJlX2NtZCA9IE5V TEw7Cj4gKwlkbC0+cG9zdF9jbWQgPSBOVUxMOwo+ICsKPiAgCS8qCj4gIAkgKiBib2R5MCBpcyBy ZXVzZWQgYXMgYXMgYW4gb3B0aW1pc2F0aW9uIGFzIHByZXNlbnRseSBldmVyeSBkaXNwbGF5IGxp c3QKPiAgCSAqIGhhcyBhdCBsZWFzdCBvbmUgYm9keSwgdGh1cyB3ZSByZWluaXRpYWxpc2UgdGhl IGVudHJpZXMgbGlzdC4KPiBAQCAtODgzLDYgKzEwNDksMTUgQEAgc3RydWN0IHZzcDFfZGxfbWFu YWdlciAqdnNwMV9kbG1fY3JlYXRlKHN0cnVjdAo+IHZzcDFfZGV2aWNlICp2c3AxLCBsaXN0X2Fk ZF90YWlsKCZkbC0+bGlzdCwgJmRsbS0+ZnJlZSk7Cj4gIAl9Cj4gCj4gKwlpZiAodnNwMV9mZWF0 dXJlKHZzcDEsIFZTUDFfSEFTX0VYVF9ETCkpIHsKPiArCQlkbG0tPmF1dG9mbGRfY21kcyA9IHZz cDFfZGxfY21kX3Bvb2xfY3JlYXRlKHZzcDEsCj4gKwkJCQkJVlNQMV9FWFRDTURfQVVUT0ZMRCwg cHJlYWxsb2MpOwo+ICsJCWlmICghZGxtLT5hdXRvZmxkX2NtZHMpIHsKPiArCQkJdnNwMV9kbG1f ZGVzdHJveShkbG0pOwo+ICsJCQlyZXR1cm4gTlVMTDsKPiArCQl9Cj4gKwl9Cj4gKwo+ICAJcmV0 dXJuIGRsbTsKPiAgfQo+IAo+IEBAIC04OTksNCArMTA3NCwyMCBAQCB2b2lkIHZzcDFfZGxtX2Rl c3Ryb3koc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxtKQo+ICAJfQo+IAo+ICAJdnNwMV9kbF9i b2R5X3Bvb2xfZGVzdHJveShkbG0tPnBvb2wpOwo+ICsJdnNwMV9kbF9leHRfY21kX3Bvb2xfZGVz dHJveShkbG0tPmF1dG9mbGRfY21kcyk7Cj4gK30KPiArCj4gK3N0cnVjdCB2c3AxX2RsX2V4dF9j bWQgKnZzcDFfZGxtX2dldF9hdXRvZmxkX2NtZChzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbCkKPiAr ewo+ICsJc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxtID0gZGwtPmRsbTsKPiArCXN0cnVjdCB2 c3AxX2RsX2V4dF9jbWQgKmNtZDsKPiArCj4gKwlpZiAoZGwtPnByZV9jbWQpCj4gKwkJcmV0dXJu IGRsLT5wcmVfY21kOwo+ICsKPiArCWNtZCA9IHZzcDFfZGxfZXh0X2NtZF9nZXQoZGxtLT5hdXRv ZmxkX2NtZHMpOwo+ICsJaWYgKGNtZCkKPiArCQlkbC0+cHJlX2NtZCA9IGNtZDsKPiArCj4gKwly ZXR1cm4gY21kOwoKWW91IGNhbiB3cml0ZSBpdCBpbiBhIHNpbXBsZXIgd2F5LgoKCWRsLT5wcmVf Y21kID0gdnNwMV9kbF9leHRfY21kX2dldChkbG0tPmF1dG9mbGRfY21kcyk7CglyZXR1cm4gZGwt PnByZV9jbWQ7Cgo+ICB9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2RsLmgKPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmggaW5k ZXggYWE1ZjRhZGM2NjE3Li5kOTYyMTIwN2IwOTMKPiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oCj4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfZGwuaAo+IEBAIC0yMiw2ICsyMiw3IEBAIHN0cnVjdCB2c3AxX2RsX21hbmFn ZXI7Cj4gCj4gIC8qKgo+ICAgKiBzdHJ1Y3QgdnNwMV9kbF9leHRfY21kIC0gRXh0ZW5kZWQgRGlz cGxheSBjb21tYW5kCj4gKyAqIEBwb29sOiBwb29sIHRvIHdoaWNoIHRoaXMgY29tbWFuZCBiZWxv bmdzCj4gICAqIEBmcmVlOiBlbnRyeSBpbiB0aGUgcG9vbCBvZiBmcmVlIGNvbW1hbmRzIGxpc3QK PiAgICogQGNtZF9vcGNvZGU6IGNvbW1hbmQgdHlwZSBvcGNvZGUKPiAgICogQGZsYWdzOiBmbGFn cyB1c2VkIGJ5IHRoZSBjb21tYW5kCj4gQEAgLTMzLDYgKzM0LDcgQEAgc3RydWN0IHZzcDFfZGxf bWFuYWdlcjsKPiAgICogQGRhdGFfc2l6ZTogc2l6ZSBvZiB0aGUgQGRhdGFfZG1hIG1lbW9yeSBp biBieXRlcwo+ICAgKi8KPiAgc3RydWN0IHZzcDFfZGxfZXh0X2NtZCB7Cj4gKwlzdHJ1Y3QgdnNw MV9kbF9jbWRfcG9vbCAqcG9vbDsKPiAgCXN0cnVjdCBsaXN0X2hlYWQgZnJlZTsKPiAKPiAgCXU4 IGNtZF9vcGNvZGU7Cj4gQEAgLTU1LDYgKzU3LDcgQEAgc3RydWN0IHZzcDFfZGxfbWFuYWdlciAq dnNwMV9kbG1fY3JlYXRlKHN0cnVjdCB2c3AxX2RldmljZQo+ICp2c3AxLCB2b2lkIHZzcDFfZGxt X2Rlc3Ryb3koc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxtKTsKPiAgdm9pZCB2c3AxX2RsbV9y ZXNldChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0pOwo+ICB1bnNpZ25lZCBpbnQgdnNwMV9k bG1faXJxX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0pOwo+ICtzdHJ1Y3Qg dnNwMV9kbF9leHRfY21kICp2c3AxX2RsbV9nZXRfYXV0b2ZsZF9jbWQoc3RydWN0IHZzcDFfZGxf bGlzdCAqZGwpOwoKU2hvdWxkIHRoaXMgYmUgbmFtZWQgdnNwMV9kbF9nZXRfYXV0b2ZsZF9jbWQo KSBhcyBpdCBvcGVyYXRlcyBvbiBhIGRsID8gSSBhbHNvIAp0aGluayB0aGF0IHlvdSBzaG91bGQg bW92ZSBpdCBkb3duIHRvIGdyb3VwIGl0IHdpdGggdGhlIGRsIGZ1bmN0aW9ucy4KCj4gIHN0cnVj dCB2c3AxX2RsX2xpc3QgKnZzcDFfZGxfbGlzdF9nZXQoc3RydWN0IHZzcDFfZGxfbWFuYWdlciAq ZGxtKTsKPiAgdm9pZCB2c3AxX2RsX2xpc3RfcHV0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsKTsK Ci0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK