From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from perceval.ideasonboard.com ([213.167.242.64]:37950 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727132AbeGMKyE (ORCPT ); Fri, 13 Jul 2018 06:54:04 -0400 Reply-To: kieran.bingham+renesas@ideasonboard.com Subject: Re: [PATCH v4 07/11] media: vsp1: Use header display lists for all WPF outputs linked to the DU To: Laurent Pinchart Cc: linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org References: <00cebb6a515fd30c47b703270cec5e40f48ae266.1525354194.git-series.kieran.bingham+renesas@ideasonboard.com> <2795301.cWJjWSonZJ@avalon> From: Kieran Bingham Message-ID: <658b0563-312f-1919-6eac-2397080d1d2d@ideasonboard.com> Date: Fri, 13 Jul 2018 11:39:54 +0100 MIME-Version: 1.0 In-Reply-To: <2795301.cWJjWSonZJ@avalon> Content-Type: text/plain; charset=utf-8 Content-Language: en-GB Content-Transfer-Encoding: 7bit Sender: linux-media-owner@vger.kernel.org List-ID: On 24/05/18 12:10, Laurent Pinchart wrote: > Hi Kieran, > > Thank you for the patch. > > On Thursday, 3 May 2018 16:36:18 EEST Kieran Bingham wrote: >> Header mode display lists are now supported on all WPF outputs. To >> support extended headers and auto-fld capabilities for interlaced mode >> handling only header mode display lists can be used. >> >> Disable the headerless display list configuration, and remove the dead >> code. >> >> Signed-off-by: Kieran Bingham >> --- >> drivers/media/platform/vsp1/vsp1_dl.c | 107 ++++++--------------------- >> 1 file changed, 27 insertions(+), 80 deletions(-) > > I like the diffstat. > >> diff --git a/drivers/media/platform/vsp1/vsp1_dl.c >> b/drivers/media/platform/vsp1/vsp1_dl.c index fbffbd407b29..56514cd51c51 >> 100644 >> --- a/drivers/media/platform/vsp1/vsp1_dl.c >> +++ b/drivers/media/platform/vsp1/vsp1_dl.c >> @@ -94,7 +94,7 @@ struct vsp1_dl_body_pool { >> * struct vsp1_dl_list - Display list >> * @list: entry in the display list manager lists >> * @dlm: the display list manager >> - * @header: display list header, NULL for headerless lists >> + * @header: display list header >> * @dma: DMA address for the header >> * @body0: first display list body >> * @bodies: list of extra display list bodies >> @@ -118,15 +118,9 @@ struct vsp1_dl_list { >> bool internal; >> }; >> >> -enum vsp1_dl_mode { >> - VSP1_DL_MODE_HEADER, >> - VSP1_DL_MODE_HEADERLESS, >> -}; >> - >> /** >> * struct vsp1_dl_manager - Display List manager >> * @index: index of the related WPF >> - * @mode: display list operation mode (header or headerless) >> * @singleshot: execute the display list in single-shot mode >> * @vsp1: the VSP1 device >> * @lock: protects the free, active, queued, and pending lists >> @@ -138,7 +132,6 @@ enum vsp1_dl_mode { >> */ >> struct vsp1_dl_manager { >> unsigned int index; >> - enum vsp1_dl_mode mode; >> bool singleshot; >> struct vsp1_device *vsp1; >> >> @@ -318,6 +311,7 @@ void vsp1_dl_body_write(struct vsp1_dl_body *dlb, u32 >> reg, u32 data) static struct vsp1_dl_list *vsp1_dl_list_alloc(struct >> vsp1_dl_manager *dlm) { >> struct vsp1_dl_list *dl; >> + size_t header_offset; >> >> dl = kzalloc(sizeof(*dl), GFP_KERNEL); >> if (!dl) >> @@ -330,16 +324,15 @@ static struct vsp1_dl_list *vsp1_dl_list_alloc(struct >> vsp1_dl_manager *dlm) dl->body0 = vsp1_dl_body_get(dlm->pool); >> if (!dl->body0) >> return NULL; >> - if (dlm->mode == VSP1_DL_MODE_HEADER) { >> - size_t header_offset = dl->body0->max_entries >> - * sizeof(*dl->body0->entries); >> >> - dl->header = ((void *)dl->body0->entries) + header_offset; >> - dl->dma = dl->body0->dma + header_offset; >> + header_offset = dl->body0->max_entries >> + * sizeof(*dl->body0->entries); > > Nitpicking, please align * under =. This fits on one line. Moved to a single line instead. > >> >> - memset(dl->header, 0, sizeof(*dl->header)); >> - dl->header->lists[0].addr = dl->body0->dma; >> - } >> + dl->header = ((void *)dl->body0->entries) + header_offset; >> + dl->dma = dl->body0->dma + header_offset; >> + >> + memset(dl->header, 0, sizeof(*dl->header)); >> + dl->header->lists[0].addr = dl->body0->dma; >> >> return dl; >> } >> @@ -471,16 +464,9 @@ struct vsp1_dl_body *vsp1_dl_list_get_body0(struct >> vsp1_dl_list *dl) * >> * The reference must be explicitly released by a call to >> vsp1_dl_body_put() * when the body isn't needed anymore. >> - * >> - * Additional bodies are only usable for display lists in header mode. >> - * Attempting to add a body to a header-less display list will return an >> error. */ >> int vsp1_dl_list_add_body(struct vsp1_dl_list *dl, struct vsp1_dl_body >> *dlb) { >> - /* Multi-body lists are only available in header mode. */ >> - if (dl->dlm->mode != VSP1_DL_MODE_HEADER) >> - return -EINVAL; >> - >> refcount_inc(&dlb->refcnt); >> >> list_add_tail(&dlb->list, &dl->bodies); >> @@ -501,17 +487,10 @@ int vsp1_dl_list_add_body(struct vsp1_dl_list *dl, >> struct vsp1_dl_body *dlb) * Adding a display list to a chain passes >> ownership of the display list to * the head display list item. The chain is >> released when the head dl item is * put back with __vsp1_dl_list_put(). >> - * >> - * Chained display lists are only usable in header mode. Attempts to add a >> - * display list to a chain in header-less mode will return an error. >> */ >> int vsp1_dl_list_add_chain(struct vsp1_dl_list *head, >> struct vsp1_dl_list *dl) >> { >> - /* Chained lists are only available in header mode. */ >> - if (head->dlm->mode != VSP1_DL_MODE_HEADER) >> - return -EINVAL; >> - >> head->has_chain = true; >> list_add_tail(&dl->chain, &head->chain); >> return 0; >> @@ -579,17 +558,10 @@ static bool vsp1_dl_list_hw_update_pending(struct >> vsp1_dl_manager *dlm) return false; >> >> /* >> - * Check whether the VSP1 has taken the update. In headerless mode the >> - * hardware indicates this by clearing the UPD bit in the DL_BODY_SIZE >> - * register, and in header mode by clearing the UPDHDR bit in the CMD >> - * register. >> + * Check whether the VSP1 has taken the update. In header mode by >> + * clearing the UPDHDR bit in the CMD register. > > I'd write this > > * Check whether the VSP1 has taken the update. The hardware indicates > * this by clearing the UPDHDR bit in the CMD register. > Agreed, Done. >> */ >> - if (dlm->mode == VSP1_DL_MODE_HEADERLESS) >> - return !!(vsp1_read(vsp1, VI6_DL_BODY_SIZE) >> - & VI6_DL_BODY_SIZE_UPD); >> - else >> - return !!(vsp1_read(vsp1, VI6_CMD(dlm->index)) >> - & VI6_CMD_UPDHDR); >> + return !!(vsp1_read(vsp1, VI6_CMD(dlm->index)) & VI6_CMD_UPDHDR); >> } >> >> static void vsp1_dl_list_hw_enqueue(struct vsp1_dl_list *dl) >> @@ -597,26 +569,14 @@ static void vsp1_dl_list_hw_enqueue(struct >> vsp1_dl_list *dl) struct vsp1_dl_manager *dlm = dl->dlm; >> struct vsp1_device *vsp1 = dlm->vsp1; >> >> - if (dlm->mode == VSP1_DL_MODE_HEADERLESS) { >> - /* >> - * In headerless mode, program the hardware directly with the >> - * display list body address and size and set the UPD bit. The >> - * bit will be cleared by the hardware when the display list >> - * processing starts. >> - */ >> - vsp1_write(vsp1, VI6_DL_HDR_ADDR(0), dl->body0->dma); >> - vsp1_write(vsp1, VI6_DL_BODY_SIZE, VI6_DL_BODY_SIZE_UPD | >> - (dl->body0->num_entries * sizeof(*dl->header->lists))); >> - } else { >> - /* >> - * In header mode, program the display list header address. If >> - * the hardware is idle (single-shot mode or first frame in >> - * continuous mode) it will then be started independently. If >> - * the hardware is operating, the VI6_DL_HDR_REF_ADDR register >> - * will be updated with the display list address. >> - */ >> - vsp1_write(vsp1, VI6_DL_HDR_ADDR(dlm->index), dl->dma); >> - } >> + /* >> + * In header mode, program the display list header address. If > > s/In header mode, program/Program/ > > You can also reformat the comment block to reach the 80th column. Done > >> + * the hardware is idle (single-shot mode or first frame in >> + * continuous mode) it will then be started independently. If >> + * the hardware is operating, the VI6_DL_HDR_REF_ADDR register >> + * will be updated with the display list address. >> + */ >> + vsp1_write(vsp1, VI6_DL_HDR_ADDR(dlm->index), dl->dma); >> } >> >> static void vsp1_dl_list_commit_continuous(struct vsp1_dl_list *dl) >> @@ -674,15 +634,13 @@ void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool >> internal) struct vsp1_dl_list *dl_next; >> unsigned long flags; >> >> - if (dlm->mode == VSP1_DL_MODE_HEADER) { >> - /* Fill the header for the head and chained display lists. */ >> - vsp1_dl_list_fill_header(dl, list_empty(&dl->chain)); >> + /* Fill the header for the head and chained display lists. */ >> + vsp1_dl_list_fill_header(dl, list_empty(&dl->chain)); >> >> - list_for_each_entry(dl_next, &dl->chain, chain) { >> - bool last = list_is_last(&dl_next->chain, &dl->chain); >> + list_for_each_entry(dl_next, &dl->chain, chain) { >> + bool last = list_is_last(&dl_next->chain, &dl->chain); >> >> - vsp1_dl_list_fill_header(dl_next, last); >> - } >> + vsp1_dl_list_fill_header(dl_next, last); >> } >> >> dl->internal = internal; >> @@ -783,13 +741,6 @@ void vsp1_dlm_setup(struct vsp1_device *vsp1) >> >> | VI6_DL_CTRL_DC2 | VI6_DL_CTRL_DC1 | VI6_DL_CTRL_DC0 >> | VI6_DL_CTRL_DLE; >> >> - /* >> - * The DRM pipeline operates with display lists in Continuous Frame >> - * Mode, all other pipelines use manual start. >> - */ >> - if (vsp1->drm) >> - ctrl |= VI6_DL_CTRL_CFM0 | VI6_DL_CTRL_NH0; >> - >> vsp1_write(vsp1, VI6_DL_CTRL, ctrl); >> vsp1_write(vsp1, VI6_DL_SWAP, VI6_DL_SWAP_LWS); >> } >> @@ -824,8 +775,6 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct >> vsp1_device *vsp1, return NULL; >> >> dlm->index = index; >> - dlm->mode = index == 0 && !vsp1->info->uapi >> - ? VSP1_DL_MODE_HEADERLESS : VSP1_DL_MODE_HEADER; >> dlm->singleshot = vsp1->info->uapi; >> dlm->vsp1 = vsp1; >> >> @@ -834,13 +783,11 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct >> vsp1_device *vsp1, >> >> /* >> * Initialize the display list body and allocate DMA memory for the body >> - * and the optional header. Both are allocated together to avoid memory >> + * and the header. Both are allocated together to avoid memory >> * fragmentation, with the header located right after the body in >> * memory. >> */ >> - header_size = dlm->mode == VSP1_DL_MODE_HEADER >> - ? ALIGN(sizeof(struct vsp1_dl_header), 8) >> - : 0; >> + header_size = ALIGN(sizeof(struct vsp1_dl_header), 8); >> >> dlm->pool = vsp1_dl_body_pool_create(vsp1, prealloc, >> VSP1_DL_NUM_ENTRIES, header_size); > > While at it, could you update the documentation of the > vsp1_dlm_irq_frame_end() function to s/header mode/single-shot mode/ ? > > With these small issues fixed, > > Reviewed-by: Laurent Pinchart Collected Thanks Kieran From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kieran Bingham Subject: Re: [PATCH v4 07/11] media: vsp1: Use header display lists for all WPF outputs linked to the DU Date: Fri, 13 Jul 2018 11:39:54 +0100 Message-ID: <658b0563-312f-1919-6eac-2397080d1d2d@ideasonboard.com> References: <00cebb6a515fd30c47b703270cec5e40f48ae266.1525354194.git-series.kieran.bingham+renesas@ideasonboard.com> <2795301.cWJjWSonZJ@avalon> Reply-To: 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 CBA0B6F204 for ; Fri, 13 Jul 2018 10:39:58 +0000 (UTC) In-Reply-To: <2795301.cWJjWSonZJ@avalon> Content-Language: en-GB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Laurent Pinchart Cc: linux-renesas-soc@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gMjQvMDUvMTggMTI6MTAsIExhdXJlbnQgUGluY2hhcnQgd3JvdGU6Cj4gSGkgS2llcmFuLAo+ IAo+IFRoYW5rIHlvdSBmb3IgdGhlIHBhdGNoLgo+IAo+IE9uIFRodXJzZGF5LCAzIE1heSAyMDE4 IDE2OjM2OjE4IEVFU1QgS2llcmFuIEJpbmdoYW0gd3JvdGU6Cj4+IEhlYWRlciBtb2RlIGRpc3Bs YXkgbGlzdHMgYXJlIG5vdyBzdXBwb3J0ZWQgb24gYWxsIFdQRiBvdXRwdXRzLiBUbwo+PiBzdXBw b3J0IGV4dGVuZGVkIGhlYWRlcnMgYW5kIGF1dG8tZmxkIGNhcGFiaWxpdGllcyBmb3IgaW50ZXJs YWNlZCBtb2RlCj4+IGhhbmRsaW5nIG9ubHkgaGVhZGVyIG1vZGUgZGlzcGxheSBsaXN0cyBjYW4g YmUgdXNlZC4KPj4KPj4gRGlzYWJsZSB0aGUgaGVhZGVybGVzcyBkaXNwbGF5IGxpc3QgY29uZmln dXJhdGlvbiwgYW5kIHJlbW92ZSB0aGUgZGVhZAo+PiBjb2RlLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5 OiBLaWVyYW4gQmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVhc29uYm9hcmQuY29t Pgo+PiAtLS0KPj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMgfCAxMDcg KysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4+ICAxIGZpbGUgY2hhbmdlZCwgMjcgaW5zZXJ0 aW9ucygrKSwgODAgZGVsZXRpb25zKC0pCj4gCj4gSSBsaWtlIHRoZSBkaWZmc3RhdC4KPiAKPj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPj4gYi9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jIGluZGV4IGZiZmZiZDQwN2IyOS4u NTY1MTRjZDUxYzUxCj4+IDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kbC5jCj4+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2Rs LmMKPj4gQEAgLTk0LDcgKzk0LDcgQEAgc3RydWN0IHZzcDFfZGxfYm9keV9wb29sIHsKPj4gICAq IHN0cnVjdCB2c3AxX2RsX2xpc3QgLSBEaXNwbGF5IGxpc3QKPj4gICAqIEBsaXN0OiBlbnRyeSBp biB0aGUgZGlzcGxheSBsaXN0IG1hbmFnZXIgbGlzdHMKPj4gICAqIEBkbG06IHRoZSBkaXNwbGF5 IGxpc3QgbWFuYWdlcgo+PiAtICogQGhlYWRlcjogZGlzcGxheSBsaXN0IGhlYWRlciwgTlVMTCBm b3IgaGVhZGVybGVzcyBsaXN0cwo+PiArICogQGhlYWRlcjogZGlzcGxheSBsaXN0IGhlYWRlcgo+ PiAgICogQGRtYTogRE1BIGFkZHJlc3MgZm9yIHRoZSBoZWFkZXIKPj4gICAqIEBib2R5MDogZmly c3QgZGlzcGxheSBsaXN0IGJvZHkKPj4gICAqIEBib2RpZXM6IGxpc3Qgb2YgZXh0cmEgZGlzcGxh eSBsaXN0IGJvZGllcwo+PiBAQCAtMTE4LDE1ICsxMTgsOSBAQCBzdHJ1Y3QgdnNwMV9kbF9saXN0 IHsKPj4gIAlib29sIGludGVybmFsOwo+PiAgfTsKPj4KPj4gLWVudW0gdnNwMV9kbF9tb2RlIHsK Pj4gLQlWU1AxX0RMX01PREVfSEVBREVSLAo+PiAtCVZTUDFfRExfTU9ERV9IRUFERVJMRVNTLAo+ PiAtfTsKPj4gLQo+PiAgLyoqCj4+ICAgKiBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyIC0gRGlzcGxh eSBMaXN0IG1hbmFnZXIKPj4gICAqIEBpbmRleDogaW5kZXggb2YgdGhlIHJlbGF0ZWQgV1BGCj4+ IC0gKiBAbW9kZTogZGlzcGxheSBsaXN0IG9wZXJhdGlvbiBtb2RlIChoZWFkZXIgb3IgaGVhZGVy bGVzcykKPj4gICAqIEBzaW5nbGVzaG90OiBleGVjdXRlIHRoZSBkaXNwbGF5IGxpc3QgaW4gc2lu Z2xlLXNob3QgbW9kZQo+PiAgICogQHZzcDE6IHRoZSBWU1AxIGRldmljZQo+PiAgICogQGxvY2s6 IHByb3RlY3RzIHRoZSBmcmVlLCBhY3RpdmUsIHF1ZXVlZCwgYW5kIHBlbmRpbmcgbGlzdHMKPj4g QEAgLTEzOCw3ICsxMzIsNiBAQCBlbnVtIHZzcDFfZGxfbW9kZSB7Cj4+ICAgKi8KPj4gIHN0cnVj dCB2c3AxX2RsX21hbmFnZXIgewo+PiAgCXVuc2lnbmVkIGludCBpbmRleDsKPj4gLQllbnVtIHZz cDFfZGxfbW9kZSBtb2RlOwo+PiAgCWJvb2wgc2luZ2xlc2hvdDsKPj4gIAlzdHJ1Y3QgdnNwMV9k ZXZpY2UgKnZzcDE7Cj4+Cj4+IEBAIC0zMTgsNiArMzExLDcgQEAgdm9pZCB2c3AxX2RsX2JvZHlf d3JpdGUoc3RydWN0IHZzcDFfZGxfYm9keSAqZGxiLCB1MzIKPj4gcmVnLCB1MzIgZGF0YSkgc3Rh dGljIHN0cnVjdCB2c3AxX2RsX2xpc3QgKnZzcDFfZGxfbGlzdF9hbGxvYyhzdHJ1Y3QKPj4gdnNw MV9kbF9tYW5hZ2VyICpkbG0pIHsKPj4gIAlzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbDsKPj4gKwlz aXplX3QgaGVhZGVyX29mZnNldDsKPj4KPj4gIAlkbCA9IGt6YWxsb2Moc2l6ZW9mKCpkbCksIEdG UF9LRVJORUwpOwo+PiAgCWlmICghZGwpCj4+IEBAIC0zMzAsMTYgKzMyNCwxNSBAQCBzdGF0aWMg c3RydWN0IHZzcDFfZGxfbGlzdCAqdnNwMV9kbF9saXN0X2FsbG9jKHN0cnVjdAo+PiB2c3AxX2Rs X21hbmFnZXIgKmRsbSkgZGwtPmJvZHkwID0gdnNwMV9kbF9ib2R5X2dldChkbG0tPnBvb2wpOwo+ PiAgCWlmICghZGwtPmJvZHkwKQo+PiAgCQlyZXR1cm4gTlVMTDsKPj4gLQlpZiAoZGxtLT5tb2Rl ID09IFZTUDFfRExfTU9ERV9IRUFERVIpIHsKPj4gLQkJc2l6ZV90IGhlYWRlcl9vZmZzZXQgPSBk bC0+Ym9keTAtPm1heF9lbnRyaWVzCj4+IC0JCQkJICAgICAqIHNpemVvZigqZGwtPmJvZHkwLT5l bnRyaWVzKTsKPj4KPj4gLQkJZGwtPmhlYWRlciA9ICgodm9pZCAqKWRsLT5ib2R5MC0+ZW50cmll cykgKyBoZWFkZXJfb2Zmc2V0Owo+PiAtCQlkbC0+ZG1hID0gZGwtPmJvZHkwLT5kbWEgKyBoZWFk ZXJfb2Zmc2V0Owo+PiArCWhlYWRlcl9vZmZzZXQgPSBkbC0+Ym9keTAtPm1heF9lbnRyaWVzCj4+ ICsJCQkgICAgICogc2l6ZW9mKCpkbC0+Ym9keTAtPmVudHJpZXMpOwo+IAo+IE5pdHBpY2tpbmcs IHBsZWFzZSBhbGlnbiAqIHVuZGVyID0uCgpUaGlzIGZpdHMgb24gb25lIGxpbmUuIE1vdmVkIHRv IGEgc2luZ2xlIGxpbmUgaW5zdGVhZC4KCj4gCj4+Cj4+IC0JCW1lbXNldChkbC0+aGVhZGVyLCAw LCBzaXplb2YoKmRsLT5oZWFkZXIpKTsKPj4gLQkJZGwtPmhlYWRlci0+bGlzdHNbMF0uYWRkciA9 IGRsLT5ib2R5MC0+ZG1hOwo+PiAtCX0KPj4gKwlkbC0+aGVhZGVyID0gKCh2b2lkICopZGwtPmJv ZHkwLT5lbnRyaWVzKSArIGhlYWRlcl9vZmZzZXQ7Cj4+ICsJZGwtPmRtYSA9IGRsLT5ib2R5MC0+ ZG1hICsgaGVhZGVyX29mZnNldDsKPj4gKwo+PiArCW1lbXNldChkbC0+aGVhZGVyLCAwLCBzaXpl b2YoKmRsLT5oZWFkZXIpKTsKPj4gKwlkbC0+aGVhZGVyLT5saXN0c1swXS5hZGRyID0gZGwtPmJv ZHkwLT5kbWE7Cj4+Cj4+ICAJcmV0dXJuIGRsOwo+PiAgfQo+PiBAQCAtNDcxLDE2ICs0NjQsOSBA QCBzdHJ1Y3QgdnNwMV9kbF9ib2R5ICp2c3AxX2RsX2xpc3RfZ2V0X2JvZHkwKHN0cnVjdAo+PiB2 c3AxX2RsX2xpc3QgKmRsKSAqCj4+ICAgKiBUaGUgcmVmZXJlbmNlIG11c3QgYmUgZXhwbGljaXRs eSByZWxlYXNlZCBieSBhIGNhbGwgdG8KPj4gdnNwMV9kbF9ib2R5X3B1dCgpICogd2hlbiB0aGUg Ym9keSBpc24ndCBuZWVkZWQgYW55bW9yZS4KPj4gLSAqCj4+IC0gKiBBZGRpdGlvbmFsIGJvZGll cyBhcmUgb25seSB1c2FibGUgZm9yIGRpc3BsYXkgbGlzdHMgaW4gaGVhZGVyIG1vZGUuCj4+IC0g KiBBdHRlbXB0aW5nIHRvIGFkZCBhIGJvZHkgdG8gYSBoZWFkZXItbGVzcyBkaXNwbGF5IGxpc3Qg d2lsbCByZXR1cm4gYW4KPj4gZXJyb3IuICovCj4+ICBpbnQgdnNwMV9kbF9saXN0X2FkZF9ib2R5 KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBzdHJ1Y3QgdnNwMV9kbF9ib2R5Cj4+ICpkbGIpIHsK Pj4gLQkvKiBNdWx0aS1ib2R5IGxpc3RzIGFyZSBvbmx5IGF2YWlsYWJsZSBpbiBoZWFkZXIgbW9k ZS4gKi8KPj4gLQlpZiAoZGwtPmRsbS0+bW9kZSAhPSBWU1AxX0RMX01PREVfSEVBREVSKQo+PiAt CQlyZXR1cm4gLUVJTlZBTDsKPj4gLQo+PiAgCXJlZmNvdW50X2luYygmZGxiLT5yZWZjbnQpOwo+ Pgo+PiAgCWxpc3RfYWRkX3RhaWwoJmRsYi0+bGlzdCwgJmRsLT5ib2RpZXMpOwo+PiBAQCAtNTAx LDE3ICs0ODcsMTAgQEAgaW50IHZzcDFfZGxfbGlzdF9hZGRfYm9keShzdHJ1Y3QgdnNwMV9kbF9s aXN0ICpkbCwKPj4gc3RydWN0IHZzcDFfZGxfYm9keSAqZGxiKSAqIEFkZGluZyBhIGRpc3BsYXkg bGlzdCB0byBhIGNoYWluIHBhc3Nlcwo+PiBvd25lcnNoaXAgb2YgdGhlIGRpc3BsYXkgbGlzdCB0 byAqIHRoZSBoZWFkIGRpc3BsYXkgbGlzdCBpdGVtLiBUaGUgY2hhaW4gaXMKPj4gcmVsZWFzZWQg d2hlbiB0aGUgaGVhZCBkbCBpdGVtIGlzICogcHV0IGJhY2sgd2l0aCBfX3ZzcDFfZGxfbGlzdF9w dXQoKS4KPj4gLSAqCj4+IC0gKiBDaGFpbmVkIGRpc3BsYXkgbGlzdHMgYXJlIG9ubHkgdXNhYmxl IGluIGhlYWRlciBtb2RlLiBBdHRlbXB0cyB0byBhZGQgYQo+PiAtICogZGlzcGxheSBsaXN0IHRv IGEgY2hhaW4gaW4gaGVhZGVyLWxlc3MgbW9kZSB3aWxsIHJldHVybiBhbiBlcnJvci4KPj4gICAq Lwo+PiAgaW50IHZzcDFfZGxfbGlzdF9hZGRfY2hhaW4oc3RydWN0IHZzcDFfZGxfbGlzdCAqaGVh ZCwKPj4gIAkJCSAgIHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsKQo+PiAgewo+PiAtCS8qIENoYWlu ZWQgbGlzdHMgYXJlIG9ubHkgYXZhaWxhYmxlIGluIGhlYWRlciBtb2RlLiAqLwo+PiAtCWlmICho ZWFkLT5kbG0tPm1vZGUgIT0gVlNQMV9ETF9NT0RFX0hFQURFUikKPj4gLQkJcmV0dXJuIC1FSU5W QUw7Cj4+IC0KPj4gIAloZWFkLT5oYXNfY2hhaW4gPSB0cnVlOwo+PiAgCWxpc3RfYWRkX3RhaWwo JmRsLT5jaGFpbiwgJmhlYWQtPmNoYWluKTsKPj4gIAlyZXR1cm4gMDsKPj4gQEAgLTU3OSwxNyAr NTU4LDEwIEBAIHN0YXRpYyBib29sIHZzcDFfZGxfbGlzdF9od191cGRhdGVfcGVuZGluZyhzdHJ1 Y3QKPj4gdnNwMV9kbF9tYW5hZ2VyICpkbG0pIHJldHVybiBmYWxzZTsKPj4KPj4gIAkvKgo+PiAt CSAqIENoZWNrIHdoZXRoZXIgdGhlIFZTUDEgaGFzIHRha2VuIHRoZSB1cGRhdGUuIEluIGhlYWRl cmxlc3MgbW9kZSB0aGUKPj4gLQkgKiBoYXJkd2FyZSBpbmRpY2F0ZXMgdGhpcyBieSBjbGVhcmlu ZyB0aGUgVVBEIGJpdCBpbiB0aGUgRExfQk9EWV9TSVpFCj4+IC0JICogcmVnaXN0ZXIsIGFuZCBp biBoZWFkZXIgbW9kZSBieSBjbGVhcmluZyB0aGUgVVBESERSIGJpdCBpbiB0aGUgQ01ECj4+IC0J ICogcmVnaXN0ZXIuCj4+ICsJICogQ2hlY2sgd2hldGhlciB0aGUgVlNQMSBoYXMgdGFrZW4gdGhl IHVwZGF0ZS4gSW4gaGVhZGVyIG1vZGUgYnkKPj4gKwkgKiBjbGVhcmluZyB0aGUgVVBESERSIGJp dCBpbiB0aGUgQ01EIHJlZ2lzdGVyLgo+IAo+IEknZCB3cml0ZSB0aGlzCj4gCj4gCSAqIENoZWNr IHdoZXRoZXIgdGhlIFZTUDEgaGFzIHRha2VuIHRoZSB1cGRhdGUuIFRoZSBoYXJkd2FyZSBpbmRp Y2F0ZXMKPiAJICogdGhpcyBieSBjbGVhcmluZyB0aGUgVVBESERSIGJpdCBpbiB0aGUgQ01EIHJl Z2lzdGVyLgo+IAoKQWdyZWVkLCBEb25lLgoKCgo+PiAgCSAqLwo+PiAtCWlmIChkbG0tPm1vZGUg PT0gVlNQMV9ETF9NT0RFX0hFQURFUkxFU1MpCj4+IC0JCXJldHVybiAhISh2c3AxX3JlYWQodnNw MSwgVkk2X0RMX0JPRFlfU0laRSkKPj4gLQkJCSAgJiBWSTZfRExfQk9EWV9TSVpFX1VQRCk7Cj4+ IC0JZWxzZQo+PiAtCQlyZXR1cm4gISEodnNwMV9yZWFkKHZzcDEsIFZJNl9DTUQoZGxtLT5pbmRl eCkpCj4+IC0JCQkgICYgVkk2X0NNRF9VUERIRFIpOwo+PiArCXJldHVybiAhISh2c3AxX3JlYWQo dnNwMSwgVkk2X0NNRChkbG0tPmluZGV4KSkgJiBWSTZfQ01EX1VQREhEUik7Cj4+ICB9Cj4+Cj4+ ICBzdGF0aWMgdm9pZCB2c3AxX2RsX2xpc3RfaHdfZW5xdWV1ZShzdHJ1Y3QgdnNwMV9kbF9saXN0 ICpkbCkKPj4gQEAgLTU5NywyNiArNTY5LDE0IEBAIHN0YXRpYyB2b2lkIHZzcDFfZGxfbGlzdF9o d19lbnF1ZXVlKHN0cnVjdAo+PiB2c3AxX2RsX2xpc3QgKmRsKSBzdHJ1Y3QgdnNwMV9kbF9tYW5h Z2VyICpkbG0gPSBkbC0+ZGxtOwo+PiAgCXN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSA9IGRsbS0+ dnNwMTsKPj4KPj4gLQlpZiAoZGxtLT5tb2RlID09IFZTUDFfRExfTU9ERV9IRUFERVJMRVNTKSB7 Cj4+IC0JCS8qCj4+IC0JCSAqIEluIGhlYWRlcmxlc3MgbW9kZSwgcHJvZ3JhbSB0aGUgaGFyZHdh cmUgZGlyZWN0bHkgd2l0aCB0aGUKPj4gLQkJICogZGlzcGxheSBsaXN0IGJvZHkgYWRkcmVzcyBh bmQgc2l6ZSBhbmQgc2V0IHRoZSBVUEQgYml0LiBUaGUKPj4gLQkJICogYml0IHdpbGwgYmUgY2xl YXJlZCBieSB0aGUgaGFyZHdhcmUgd2hlbiB0aGUgZGlzcGxheSBsaXN0Cj4+IC0JCSAqIHByb2Nl c3Npbmcgc3RhcnRzLgo+PiAtCQkgKi8KPj4gLQkJdnNwMV93cml0ZSh2c3AxLCBWSTZfRExfSERS X0FERFIoMCksIGRsLT5ib2R5MC0+ZG1hKTsKPj4gLQkJdnNwMV93cml0ZSh2c3AxLCBWSTZfRExf Qk9EWV9TSVpFLCBWSTZfRExfQk9EWV9TSVpFX1VQRCB8Cj4+IC0JCQkoZGwtPmJvZHkwLT5udW1f ZW50cmllcyAqIHNpemVvZigqZGwtPmhlYWRlci0+bGlzdHMpKSk7Cj4+IC0JfSBlbHNlIHsKPj4g LQkJLyoKPj4gLQkJICogSW4gaGVhZGVyIG1vZGUsIHByb2dyYW0gdGhlIGRpc3BsYXkgbGlzdCBo ZWFkZXIgYWRkcmVzcy4gSWYKPj4gLQkJICogdGhlIGhhcmR3YXJlIGlzIGlkbGUgKHNpbmdsZS1z aG90IG1vZGUgb3IgZmlyc3QgZnJhbWUgaW4KPj4gLQkJICogY29udGludW91cyBtb2RlKSBpdCB3 aWxsIHRoZW4gYmUgc3RhcnRlZCBpbmRlcGVuZGVudGx5LiBJZgo+PiAtCQkgKiB0aGUgaGFyZHdh cmUgaXMgb3BlcmF0aW5nLCB0aGUgVkk2X0RMX0hEUl9SRUZfQUREUiByZWdpc3Rlcgo+PiAtCQkg KiB3aWxsIGJlIHVwZGF0ZWQgd2l0aCB0aGUgZGlzcGxheSBsaXN0IGFkZHJlc3MuCj4+IC0JCSAq Lwo+PiAtCQl2c3AxX3dyaXRlKHZzcDEsIFZJNl9ETF9IRFJfQUREUihkbG0tPmluZGV4KSwgZGwt PmRtYSk7Cj4+IC0JfQo+PiArCS8qCj4+ICsJICogSW4gaGVhZGVyIG1vZGUsIHByb2dyYW0gdGhl IGRpc3BsYXkgbGlzdCBoZWFkZXIgYWRkcmVzcy4gSWYKPiAKPiBzL0luIGhlYWRlciBtb2RlLCBw cm9ncmFtL1Byb2dyYW0vCj4gCj4gWW91IGNhbiBhbHNvIHJlZm9ybWF0IHRoZSBjb21tZW50IGJs b2NrIHRvIHJlYWNoIHRoZSA4MHRoIGNvbHVtbi4KCkRvbmUKCgo+IAo+PiArCSAqIHRoZSBoYXJk d2FyZSBpcyBpZGxlIChzaW5nbGUtc2hvdCBtb2RlIG9yIGZpcnN0IGZyYW1lIGluCj4+ICsJICog Y29udGludW91cyBtb2RlKSBpdCB3aWxsIHRoZW4gYmUgc3RhcnRlZCBpbmRlcGVuZGVudGx5LiBJ Zgo+PiArCSAqIHRoZSBoYXJkd2FyZSBpcyBvcGVyYXRpbmcsIHRoZSBWSTZfRExfSERSX1JFRl9B RERSIHJlZ2lzdGVyCj4+ICsJICogd2lsbCBiZSB1cGRhdGVkIHdpdGggdGhlIGRpc3BsYXkgbGlz dCBhZGRyZXNzLgo+PiArCSAqLwo+PiArCXZzcDFfd3JpdGUodnNwMSwgVkk2X0RMX0hEUl9BRERS KGRsbS0+aW5kZXgpLCBkbC0+ZG1hKTsKPj4gIH0KPj4KPj4gIHN0YXRpYyB2b2lkIHZzcDFfZGxf bGlzdF9jb21taXRfY29udGludW91cyhzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbCkKPj4gQEAgLTY3 NCwxNSArNjM0LDEzIEBAIHZvaWQgdnNwMV9kbF9saXN0X2NvbW1pdChzdHJ1Y3QgdnNwMV9kbF9s aXN0ICpkbCwgYm9vbAo+PiBpbnRlcm5hbCkgc3RydWN0IHZzcDFfZGxfbGlzdCAqZGxfbmV4dDsK Pj4gIAl1bnNpZ25lZCBsb25nIGZsYWdzOwo+Pgo+PiAtCWlmIChkbG0tPm1vZGUgPT0gVlNQMV9E TF9NT0RFX0hFQURFUikgewo+PiAtCQkvKiBGaWxsIHRoZSBoZWFkZXIgZm9yIHRoZSBoZWFkIGFu ZCBjaGFpbmVkIGRpc3BsYXkgbGlzdHMuICovCj4+IC0JCXZzcDFfZGxfbGlzdF9maWxsX2hlYWRl cihkbCwgbGlzdF9lbXB0eSgmZGwtPmNoYWluKSk7Cj4+ICsJLyogRmlsbCB0aGUgaGVhZGVyIGZv ciB0aGUgaGVhZCBhbmQgY2hhaW5lZCBkaXNwbGF5IGxpc3RzLiAqLwo+PiArCXZzcDFfZGxfbGlz dF9maWxsX2hlYWRlcihkbCwgbGlzdF9lbXB0eSgmZGwtPmNoYWluKSk7Cj4+Cj4+IC0JCWxpc3Rf Zm9yX2VhY2hfZW50cnkoZGxfbmV4dCwgJmRsLT5jaGFpbiwgY2hhaW4pIHsKPj4gLQkJCWJvb2wg bGFzdCA9IGxpc3RfaXNfbGFzdCgmZGxfbmV4dC0+Y2hhaW4sICZkbC0+Y2hhaW4pOwo+PiArCWxp c3RfZm9yX2VhY2hfZW50cnkoZGxfbmV4dCwgJmRsLT5jaGFpbiwgY2hhaW4pIHsKPj4gKwkJYm9v bCBsYXN0ID0gbGlzdF9pc19sYXN0KCZkbF9uZXh0LT5jaGFpbiwgJmRsLT5jaGFpbik7Cj4+Cj4+ IC0JCQl2c3AxX2RsX2xpc3RfZmlsbF9oZWFkZXIoZGxfbmV4dCwgbGFzdCk7Cj4+IC0JCX0KPj4g KwkJdnNwMV9kbF9saXN0X2ZpbGxfaGVhZGVyKGRsX25leHQsIGxhc3QpOwo+PiAgCX0KPj4KPj4g IAlkbC0+aW50ZXJuYWwgPSBpbnRlcm5hbDsKPj4gQEAgLTc4MywxMyArNzQxLDYgQEAgdm9pZCB2 c3AxX2RsbV9zZXR1cChzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEpCj4+Cj4+ICAJCSB8IFZJNl9E TF9DVFJMX0RDMiB8IFZJNl9ETF9DVFJMX0RDMSB8IFZJNl9ETF9DVFJMX0RDMAo+PiAgCQkgfCBW STZfRExfQ1RSTF9ETEU7Cj4+Cj4+IC0JLyoKPj4gLQkgKiBUaGUgRFJNIHBpcGVsaW5lIG9wZXJh dGVzIHdpdGggZGlzcGxheSBsaXN0cyBpbiBDb250aW51b3VzIEZyYW1lCj4+IC0JICogTW9kZSwg YWxsIG90aGVyIHBpcGVsaW5lcyB1c2UgbWFudWFsIHN0YXJ0Lgo+PiAtCSAqLwo+PiAtCWlmICh2 c3AxLT5kcm0pCj4+IC0JCWN0cmwgfD0gVkk2X0RMX0NUUkxfQ0ZNMCB8IFZJNl9ETF9DVFJMX05I MDsKPj4gLQo+PiAgCXZzcDFfd3JpdGUodnNwMSwgVkk2X0RMX0NUUkwsIGN0cmwpOwo+PiAgCXZz cDFfd3JpdGUodnNwMSwgVkk2X0RMX1NXQVAsIFZJNl9ETF9TV0FQX0xXUyk7Cj4+ICB9Cj4+IEBA IC04MjQsOCArNzc1LDYgQEAgc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqdnNwMV9kbG1fY3JlYXRl KHN0cnVjdAo+PiB2c3AxX2RldmljZSAqdnNwMSwgcmV0dXJuIE5VTEw7Cj4+Cj4+ICAJZGxtLT5p bmRleCA9IGluZGV4Owo+PiAtCWRsbS0+bW9kZSA9IGluZGV4ID09IDAgJiYgIXZzcDEtPmluZm8t PnVhcGkKPj4gLQkJICA/IFZTUDFfRExfTU9ERV9IRUFERVJMRVNTIDogVlNQMV9ETF9NT0RFX0hF QURFUjsKPj4gIAlkbG0tPnNpbmdsZXNob3QgPSB2c3AxLT5pbmZvLT51YXBpOwo+PiAgCWRsbS0+ dnNwMSA9IHZzcDE7Cj4+Cj4+IEBAIC04MzQsMTMgKzc4MywxMSBAQCBzdHJ1Y3QgdnNwMV9kbF9t YW5hZ2VyICp2c3AxX2RsbV9jcmVhdGUoc3RydWN0Cj4+IHZzcDFfZGV2aWNlICp2c3AxLAo+Pgo+ PiAgCS8qCj4+ICAJICogSW5pdGlhbGl6ZSB0aGUgZGlzcGxheSBsaXN0IGJvZHkgYW5kIGFsbG9j YXRlIERNQSBtZW1vcnkgZm9yIHRoZSBib2R5Cj4+IC0JICogYW5kIHRoZSBvcHRpb25hbCBoZWFk ZXIuIEJvdGggYXJlIGFsbG9jYXRlZCB0b2dldGhlciB0byBhdm9pZCBtZW1vcnkKPj4gKwkgKiBh bmQgdGhlIGhlYWRlci4gQm90aCBhcmUgYWxsb2NhdGVkIHRvZ2V0aGVyIHRvIGF2b2lkIG1lbW9y eQo+PiAgCSAqIGZyYWdtZW50YXRpb24sIHdpdGggdGhlIGhlYWRlciBsb2NhdGVkIHJpZ2h0IGFm dGVyIHRoZSBib2R5IGluCj4+ICAJICogbWVtb3J5Lgo+PiAgCSAqLwo+PiAtCWhlYWRlcl9zaXpl ID0gZGxtLT5tb2RlID09IFZTUDFfRExfTU9ERV9IRUFERVIKPj4gLQkJICAgID8gQUxJR04oc2l6 ZW9mKHN0cnVjdCB2c3AxX2RsX2hlYWRlciksIDgpCj4+IC0JCSAgICA6IDA7Cj4+ICsJaGVhZGVy X3NpemUgPSBBTElHTihzaXplb2Yoc3RydWN0IHZzcDFfZGxfaGVhZGVyKSwgOCk7Cj4+Cj4+ICAJ ZGxtLT5wb29sID0gdnNwMV9kbF9ib2R5X3Bvb2xfY3JlYXRlKHZzcDEsIHByZWFsbG9jLAo+PiAg CQkJCQkgICAgIFZTUDFfRExfTlVNX0VOVFJJRVMsIGhlYWRlcl9zaXplKTsKPiAKPiBXaGlsZSBh dCBpdCwgY291bGQgeW91IHVwZGF0ZSB0aGUgZG9jdW1lbnRhdGlvbiBvZiB0aGUgCj4gdnNwMV9k bG1faXJxX2ZyYW1lX2VuZCgpIGZ1bmN0aW9uIHRvIHMvaGVhZGVyIG1vZGUvc2luZ2xlLXNob3Qg bW9kZS8gPwo+IAo+IFdpdGggdGhlc2Ugc21hbGwgaXNzdWVzIGZpeGVkLAo+IAo+IFJldmlld2Vk LWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25ib2FyZC5jb20+ CgpDb2xsZWN0ZWQKClRoYW5rcwoKS2llcmFuCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxp c3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2RyaS1kZXZlbAo=