From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:44738 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1032891AbeEXLKQ (ORCPT ); Thu, 24 May 2018 07:10:16 -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 07/11] media: vsp1: Use header display lists for all WPF outputs linked to the DU Date: Thu, 24 May 2018 14:10:10 +0300 Message-ID: <2795301.cWJjWSonZJ@avalon> In-Reply-To: <00cebb6a515fd30c47b703270cec5e40f48ae266.1525354194.git-series.kieran.bingham+renesas@ideasonboard.com> References: <00cebb6a515fd30c47b703270cec5e40f48ae266.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: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 =. > > - 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. > */ > - 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. > + * 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 -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v4 07/11] media: vsp1: Use header display lists for all WPF outputs linked to the DU Date: Thu, 24 May 2018 14:10:10 +0300 Message-ID: <2795301.cWJjWSonZJ@avalon> References: <00cebb6a515fd30c47b703270cec5e40f48ae266.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 750FB6E5BF for ; Thu, 24 May 2018 11:10:15 +0000 (UTC) In-Reply-To: <00cebb6a515fd30c47b703270cec5e40f48ae266.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 MjAxOCAxNjozNjoxOCBFRVNUIEtpZXJhbiBCaW5naGFtIHdyb3RlOgo+IEhlYWRlciBtb2RlIGRp c3BsYXkgbGlzdHMgYXJlIG5vdyBzdXBwb3J0ZWQgb24gYWxsIFdQRiBvdXRwdXRzLiBUbwo+IHN1 cHBvcnQgZXh0ZW5kZWQgaGVhZGVycyBhbmQgYXV0by1mbGQgY2FwYWJpbGl0aWVzIGZvciBpbnRl cmxhY2VkIG1vZGUKPiBoYW5kbGluZyBvbmx5IGhlYWRlciBtb2RlIGRpc3BsYXkgbGlzdHMgY2Fu IGJlIHVzZWQuCj4gCj4gRGlzYWJsZSB0aGUgaGVhZGVybGVzcyBkaXNwbGF5IGxpc3QgY29uZmln dXJhdGlvbiwgYW5kIHJlbW92ZSB0aGUgZGVhZAo+IGNvZGUuCj4gCj4gU2lnbmVkLW9mZi1ieTog S2llcmFuIEJpbmdoYW0gPGtpZXJhbi5iaW5naGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4K PiAtLS0KPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYyB8IDEwNyArKysr KystLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAgMSBmaWxlIGNoYW5nZWQsIDI3IGluc2VydGlvbnMo KyksIDgwIGRlbGV0aW9ucygtKQoKSSBsaWtlIHRoZSBkaWZmc3RhdC4KCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiBiL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX2RsLmMgaW5kZXggZmJmZmJkNDA3YjI5Li41NjUxNGNkNTFjNTEK PiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jCj4g KysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+IEBAIC05NCw3ICs5 NCw3IEBAIHN0cnVjdCB2c3AxX2RsX2JvZHlfcG9vbCB7Cj4gICAqIHN0cnVjdCB2c3AxX2RsX2xp c3QgLSBEaXNwbGF5IGxpc3QKPiAgICogQGxpc3Q6IGVudHJ5IGluIHRoZSBkaXNwbGF5IGxpc3Qg bWFuYWdlciBsaXN0cwo+ICAgKiBAZGxtOiB0aGUgZGlzcGxheSBsaXN0IG1hbmFnZXIKPiAtICog QGhlYWRlcjogZGlzcGxheSBsaXN0IGhlYWRlciwgTlVMTCBmb3IgaGVhZGVybGVzcyBsaXN0cwo+ ICsgKiBAaGVhZGVyOiBkaXNwbGF5IGxpc3QgaGVhZGVyCj4gICAqIEBkbWE6IERNQSBhZGRyZXNz IGZvciB0aGUgaGVhZGVyCj4gICAqIEBib2R5MDogZmlyc3QgZGlzcGxheSBsaXN0IGJvZHkKPiAg ICogQGJvZGllczogbGlzdCBvZiBleHRyYSBkaXNwbGF5IGxpc3QgYm9kaWVzCj4gQEAgLTExOCwx NSArMTE4LDkgQEAgc3RydWN0IHZzcDFfZGxfbGlzdCB7Cj4gIAlib29sIGludGVybmFsOwo+ICB9 Owo+IAo+IC1lbnVtIHZzcDFfZGxfbW9kZSB7Cj4gLQlWU1AxX0RMX01PREVfSEVBREVSLAo+IC0J VlNQMV9ETF9NT0RFX0hFQURFUkxFU1MsCj4gLX07Cj4gLQo+ICAvKioKPiAgICogc3RydWN0IHZz cDFfZGxfbWFuYWdlciAtIERpc3BsYXkgTGlzdCBtYW5hZ2VyCj4gICAqIEBpbmRleDogaW5kZXgg b2YgdGhlIHJlbGF0ZWQgV1BGCj4gLSAqIEBtb2RlOiBkaXNwbGF5IGxpc3Qgb3BlcmF0aW9uIG1v ZGUgKGhlYWRlciBvciBoZWFkZXJsZXNzKQo+ICAgKiBAc2luZ2xlc2hvdDogZXhlY3V0ZSB0aGUg ZGlzcGxheSBsaXN0IGluIHNpbmdsZS1zaG90IG1vZGUKPiAgICogQHZzcDE6IHRoZSBWU1AxIGRl dmljZQo+ICAgKiBAbG9jazogcHJvdGVjdHMgdGhlIGZyZWUsIGFjdGl2ZSwgcXVldWVkLCBhbmQg cGVuZGluZyBsaXN0cwo+IEBAIC0xMzgsNyArMTMyLDYgQEAgZW51bSB2c3AxX2RsX21vZGUgewo+ ICAgKi8KPiAgc3RydWN0IHZzcDFfZGxfbWFuYWdlciB7Cj4gIAl1bnNpZ25lZCBpbnQgaW5kZXg7 Cj4gLQllbnVtIHZzcDFfZGxfbW9kZSBtb2RlOwo+ICAJYm9vbCBzaW5nbGVzaG90Owo+ICAJc3Ry dWN0IHZzcDFfZGV2aWNlICp2c3AxOwo+IAo+IEBAIC0zMTgsNiArMzExLDcgQEAgdm9pZCB2c3Ax X2RsX2JvZHlfd3JpdGUoc3RydWN0IHZzcDFfZGxfYm9keSAqZGxiLCB1MzIKPiByZWcsIHUzMiBk YXRhKSBzdGF0aWMgc3RydWN0IHZzcDFfZGxfbGlzdCAqdnNwMV9kbF9saXN0X2FsbG9jKHN0cnVj dAo+IHZzcDFfZGxfbWFuYWdlciAqZGxtKSB7Cj4gIAlzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbDsK PiArCXNpemVfdCBoZWFkZXJfb2Zmc2V0Owo+IAo+ICAJZGwgPSBremFsbG9jKHNpemVvZigqZGwp LCBHRlBfS0VSTkVMKTsKPiAgCWlmICghZGwpCj4gQEAgLTMzMCwxNiArMzI0LDE1IEBAIHN0YXRp YyBzdHJ1Y3QgdnNwMV9kbF9saXN0ICp2c3AxX2RsX2xpc3RfYWxsb2Moc3RydWN0Cj4gdnNwMV9k bF9tYW5hZ2VyICpkbG0pIGRsLT5ib2R5MCA9IHZzcDFfZGxfYm9keV9nZXQoZGxtLT5wb29sKTsK PiAgCWlmICghZGwtPmJvZHkwKQo+ICAJCXJldHVybiBOVUxMOwo+IC0JaWYgKGRsbS0+bW9kZSA9 PSBWU1AxX0RMX01PREVfSEVBREVSKSB7Cj4gLQkJc2l6ZV90IGhlYWRlcl9vZmZzZXQgPSBkbC0+ Ym9keTAtPm1heF9lbnRyaWVzCj4gLQkJCQkgICAgICogc2l6ZW9mKCpkbC0+Ym9keTAtPmVudHJp ZXMpOwo+IAo+IC0JCWRsLT5oZWFkZXIgPSAoKHZvaWQgKilkbC0+Ym9keTAtPmVudHJpZXMpICsg aGVhZGVyX29mZnNldDsKPiAtCQlkbC0+ZG1hID0gZGwtPmJvZHkwLT5kbWEgKyBoZWFkZXJfb2Zm c2V0Owo+ICsJaGVhZGVyX29mZnNldCA9IGRsLT5ib2R5MC0+bWF4X2VudHJpZXMKPiArCQkJICAg ICAqIHNpemVvZigqZGwtPmJvZHkwLT5lbnRyaWVzKTsKCk5pdHBpY2tpbmcsIHBsZWFzZSBhbGln biAqIHVuZGVyID0uCgo+IAo+IC0JCW1lbXNldChkbC0+aGVhZGVyLCAwLCBzaXplb2YoKmRsLT5o ZWFkZXIpKTsKPiAtCQlkbC0+aGVhZGVyLT5saXN0c1swXS5hZGRyID0gZGwtPmJvZHkwLT5kbWE7 Cj4gLQl9Cj4gKwlkbC0+aGVhZGVyID0gKCh2b2lkICopZGwtPmJvZHkwLT5lbnRyaWVzKSArIGhl YWRlcl9vZmZzZXQ7Cj4gKwlkbC0+ZG1hID0gZGwtPmJvZHkwLT5kbWEgKyBoZWFkZXJfb2Zmc2V0 Owo+ICsKPiArCW1lbXNldChkbC0+aGVhZGVyLCAwLCBzaXplb2YoKmRsLT5oZWFkZXIpKTsKPiAr CWRsLT5oZWFkZXItPmxpc3RzWzBdLmFkZHIgPSBkbC0+Ym9keTAtPmRtYTsKPiAKPiAgCXJldHVy biBkbDsKPiAgfQo+IEBAIC00NzEsMTYgKzQ2NCw5IEBAIHN0cnVjdCB2c3AxX2RsX2JvZHkgKnZz cDFfZGxfbGlzdF9nZXRfYm9keTAoc3RydWN0Cj4gdnNwMV9kbF9saXN0ICpkbCkgKgo+ICAgKiBU aGUgcmVmZXJlbmNlIG11c3QgYmUgZXhwbGljaXRseSByZWxlYXNlZCBieSBhIGNhbGwgdG8KPiB2 c3AxX2RsX2JvZHlfcHV0KCkgKiB3aGVuIHRoZSBib2R5IGlzbid0IG5lZWRlZCBhbnltb3JlLgo+ IC0gKgo+IC0gKiBBZGRpdGlvbmFsIGJvZGllcyBhcmUgb25seSB1c2FibGUgZm9yIGRpc3BsYXkg bGlzdHMgaW4gaGVhZGVyIG1vZGUuCj4gLSAqIEF0dGVtcHRpbmcgdG8gYWRkIGEgYm9keSB0byBh IGhlYWRlci1sZXNzIGRpc3BsYXkgbGlzdCB3aWxsIHJldHVybiBhbgo+IGVycm9yLiAqLwo+ICBp bnQgdnNwMV9kbF9saXN0X2FkZF9ib2R5KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBzdHJ1Y3Qg dnNwMV9kbF9ib2R5Cj4gKmRsYikgewo+IC0JLyogTXVsdGktYm9keSBsaXN0cyBhcmUgb25seSBh dmFpbGFibGUgaW4gaGVhZGVyIG1vZGUuICovCj4gLQlpZiAoZGwtPmRsbS0+bW9kZSAhPSBWU1Ax X0RMX01PREVfSEVBREVSKQo+IC0JCXJldHVybiAtRUlOVkFMOwo+IC0KPiAgCXJlZmNvdW50X2lu YygmZGxiLT5yZWZjbnQpOwo+IAo+ICAJbGlzdF9hZGRfdGFpbCgmZGxiLT5saXN0LCAmZGwtPmJv ZGllcyk7Cj4gQEAgLTUwMSwxNyArNDg3LDEwIEBAIGludCB2c3AxX2RsX2xpc3RfYWRkX2JvZHko c3RydWN0IHZzcDFfZGxfbGlzdCAqZGwsCj4gc3RydWN0IHZzcDFfZGxfYm9keSAqZGxiKSAqIEFk ZGluZyBhIGRpc3BsYXkgbGlzdCB0byBhIGNoYWluIHBhc3Nlcwo+IG93bmVyc2hpcCBvZiB0aGUg ZGlzcGxheSBsaXN0IHRvICogdGhlIGhlYWQgZGlzcGxheSBsaXN0IGl0ZW0uIFRoZSBjaGFpbiBp cwo+IHJlbGVhc2VkIHdoZW4gdGhlIGhlYWQgZGwgaXRlbSBpcyAqIHB1dCBiYWNrIHdpdGggX192 c3AxX2RsX2xpc3RfcHV0KCkuCj4gLSAqCj4gLSAqIENoYWluZWQgZGlzcGxheSBsaXN0cyBhcmUg b25seSB1c2FibGUgaW4gaGVhZGVyIG1vZGUuIEF0dGVtcHRzIHRvIGFkZCBhCj4gLSAqIGRpc3Bs YXkgbGlzdCB0byBhIGNoYWluIGluIGhlYWRlci1sZXNzIG1vZGUgd2lsbCByZXR1cm4gYW4gZXJy b3IuCj4gICAqLwo+ICBpbnQgdnNwMV9kbF9saXN0X2FkZF9jaGFpbihzdHJ1Y3QgdnNwMV9kbF9s aXN0ICpoZWFkLAo+ICAJCQkgICBzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbCkKPiAgewo+IC0JLyog Q2hhaW5lZCBsaXN0cyBhcmUgb25seSBhdmFpbGFibGUgaW4gaGVhZGVyIG1vZGUuICovCj4gLQlp ZiAoaGVhZC0+ZGxtLT5tb2RlICE9IFZTUDFfRExfTU9ERV9IRUFERVIpCj4gLQkJcmV0dXJuIC1F SU5WQUw7Cj4gLQo+ICAJaGVhZC0+aGFzX2NoYWluID0gdHJ1ZTsKPiAgCWxpc3RfYWRkX3RhaWwo JmRsLT5jaGFpbiwgJmhlYWQtPmNoYWluKTsKPiAgCXJldHVybiAwOwo+IEBAIC01NzksMTcgKzU1 OCwxMCBAQCBzdGF0aWMgYm9vbCB2c3AxX2RsX2xpc3RfaHdfdXBkYXRlX3BlbmRpbmcoc3RydWN0 Cj4gdnNwMV9kbF9tYW5hZ2VyICpkbG0pIHJldHVybiBmYWxzZTsKPiAKPiAgCS8qCj4gLQkgKiBD aGVjayB3aGV0aGVyIHRoZSBWU1AxIGhhcyB0YWtlbiB0aGUgdXBkYXRlLiBJbiBoZWFkZXJsZXNz IG1vZGUgdGhlCj4gLQkgKiBoYXJkd2FyZSBpbmRpY2F0ZXMgdGhpcyBieSBjbGVhcmluZyB0aGUg VVBEIGJpdCBpbiB0aGUgRExfQk9EWV9TSVpFCj4gLQkgKiByZWdpc3RlciwgYW5kIGluIGhlYWRl ciBtb2RlIGJ5IGNsZWFyaW5nIHRoZSBVUERIRFIgYml0IGluIHRoZSBDTUQKPiAtCSAqIHJlZ2lz dGVyLgo+ICsJICogQ2hlY2sgd2hldGhlciB0aGUgVlNQMSBoYXMgdGFrZW4gdGhlIHVwZGF0ZS4g SW4gaGVhZGVyIG1vZGUgYnkKPiArCSAqIGNsZWFyaW5nIHRoZSBVUERIRFIgYml0IGluIHRoZSBD TUQgcmVnaXN0ZXIuCgpJJ2Qgd3JpdGUgdGhpcwoKCSAqIENoZWNrIHdoZXRoZXIgdGhlIFZTUDEg aGFzIHRha2VuIHRoZSB1cGRhdGUuIFRoZSBoYXJkd2FyZSBpbmRpY2F0ZXMKCSAqIHRoaXMgYnkg Y2xlYXJpbmcgdGhlIFVQREhEUiBiaXQgaW4gdGhlIENNRCByZWdpc3Rlci4KCj4gIAkgKi8KPiAt CWlmIChkbG0tPm1vZGUgPT0gVlNQMV9ETF9NT0RFX0hFQURFUkxFU1MpCj4gLQkJcmV0dXJuICEh KHZzcDFfcmVhZCh2c3AxLCBWSTZfRExfQk9EWV9TSVpFKQo+IC0JCQkgICYgVkk2X0RMX0JPRFlf U0laRV9VUEQpOwo+IC0JZWxzZQo+IC0JCXJldHVybiAhISh2c3AxX3JlYWQodnNwMSwgVkk2X0NN RChkbG0tPmluZGV4KSkKPiAtCQkJICAmIFZJNl9DTURfVVBESERSKTsKPiArCXJldHVybiAhISh2 c3AxX3JlYWQodnNwMSwgVkk2X0NNRChkbG0tPmluZGV4KSkgJiBWSTZfQ01EX1VQREhEUik7Cj4g IH0KPiAKPiAgc3RhdGljIHZvaWQgdnNwMV9kbF9saXN0X2h3X2VucXVldWUoc3RydWN0IHZzcDFf ZGxfbGlzdCAqZGwpCj4gQEAgLTU5NywyNiArNTY5LDE0IEBAIHN0YXRpYyB2b2lkIHZzcDFfZGxf bGlzdF9od19lbnF1ZXVlKHN0cnVjdAo+IHZzcDFfZGxfbGlzdCAqZGwpIHN0cnVjdCB2c3AxX2Rs X21hbmFnZXIgKmRsbSA9IGRsLT5kbG07Cj4gIAlzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEgPSBk bG0tPnZzcDE7Cj4gCj4gLQlpZiAoZGxtLT5tb2RlID09IFZTUDFfRExfTU9ERV9IRUFERVJMRVNT KSB7Cj4gLQkJLyoKPiAtCQkgKiBJbiBoZWFkZXJsZXNzIG1vZGUsIHByb2dyYW0gdGhlIGhhcmR3 YXJlIGRpcmVjdGx5IHdpdGggdGhlCj4gLQkJICogZGlzcGxheSBsaXN0IGJvZHkgYWRkcmVzcyBh bmQgc2l6ZSBhbmQgc2V0IHRoZSBVUEQgYml0LiBUaGUKPiAtCQkgKiBiaXQgd2lsbCBiZSBjbGVh cmVkIGJ5IHRoZSBoYXJkd2FyZSB3aGVuIHRoZSBkaXNwbGF5IGxpc3QKPiAtCQkgKiBwcm9jZXNz aW5nIHN0YXJ0cy4KPiAtCQkgKi8KPiAtCQl2c3AxX3dyaXRlKHZzcDEsIFZJNl9ETF9IRFJfQURE UigwKSwgZGwtPmJvZHkwLT5kbWEpOwo+IC0JCXZzcDFfd3JpdGUodnNwMSwgVkk2X0RMX0JPRFlf U0laRSwgVkk2X0RMX0JPRFlfU0laRV9VUEQgfAo+IC0JCQkoZGwtPmJvZHkwLT5udW1fZW50cmll cyAqIHNpemVvZigqZGwtPmhlYWRlci0+bGlzdHMpKSk7Cj4gLQl9IGVsc2Ugewo+IC0JCS8qCj4g LQkJICogSW4gaGVhZGVyIG1vZGUsIHByb2dyYW0gdGhlIGRpc3BsYXkgbGlzdCBoZWFkZXIgYWRk cmVzcy4gSWYKPiAtCQkgKiB0aGUgaGFyZHdhcmUgaXMgaWRsZSAoc2luZ2xlLXNob3QgbW9kZSBv ciBmaXJzdCBmcmFtZSBpbgo+IC0JCSAqIGNvbnRpbnVvdXMgbW9kZSkgaXQgd2lsbCB0aGVuIGJl IHN0YXJ0ZWQgaW5kZXBlbmRlbnRseS4gSWYKPiAtCQkgKiB0aGUgaGFyZHdhcmUgaXMgb3BlcmF0 aW5nLCB0aGUgVkk2X0RMX0hEUl9SRUZfQUREUiByZWdpc3Rlcgo+IC0JCSAqIHdpbGwgYmUgdXBk YXRlZCB3aXRoIHRoZSBkaXNwbGF5IGxpc3QgYWRkcmVzcy4KPiAtCQkgKi8KPiAtCQl2c3AxX3dy aXRlKHZzcDEsIFZJNl9ETF9IRFJfQUREUihkbG0tPmluZGV4KSwgZGwtPmRtYSk7Cj4gLQl9Cj4g KwkvKgo+ICsJICogSW4gaGVhZGVyIG1vZGUsIHByb2dyYW0gdGhlIGRpc3BsYXkgbGlzdCBoZWFk ZXIgYWRkcmVzcy4gSWYKCnMvSW4gaGVhZGVyIG1vZGUsIHByb2dyYW0vUHJvZ3JhbS8KCllvdSBj YW4gYWxzbyByZWZvcm1hdCB0aGUgY29tbWVudCBibG9jayB0byByZWFjaCB0aGUgODB0aCBjb2x1 bW4uCgo+ICsJICogdGhlIGhhcmR3YXJlIGlzIGlkbGUgKHNpbmdsZS1zaG90IG1vZGUgb3IgZmly c3QgZnJhbWUgaW4KPiArCSAqIGNvbnRpbnVvdXMgbW9kZSkgaXQgd2lsbCB0aGVuIGJlIHN0YXJ0 ZWQgaW5kZXBlbmRlbnRseS4gSWYKPiArCSAqIHRoZSBoYXJkd2FyZSBpcyBvcGVyYXRpbmcsIHRo ZSBWSTZfRExfSERSX1JFRl9BRERSIHJlZ2lzdGVyCj4gKwkgKiB3aWxsIGJlIHVwZGF0ZWQgd2l0 aCB0aGUgZGlzcGxheSBsaXN0IGFkZHJlc3MuCj4gKwkgKi8KPiArCXZzcDFfd3JpdGUodnNwMSwg Vkk2X0RMX0hEUl9BRERSKGRsbS0+aW5kZXgpLCBkbC0+ZG1hKTsKPiAgfQo+IAo+ICBzdGF0aWMg dm9pZCB2c3AxX2RsX2xpc3RfY29tbWl0X2NvbnRpbnVvdXMoc3RydWN0IHZzcDFfZGxfbGlzdCAq ZGwpCj4gQEAgLTY3NCwxNSArNjM0LDEzIEBAIHZvaWQgdnNwMV9kbF9saXN0X2NvbW1pdChzdHJ1 Y3QgdnNwMV9kbF9saXN0ICpkbCwgYm9vbAo+IGludGVybmFsKSBzdHJ1Y3QgdnNwMV9kbF9saXN0 ICpkbF9uZXh0Owo+ICAJdW5zaWduZWQgbG9uZyBmbGFnczsKPiAKPiAtCWlmIChkbG0tPm1vZGUg PT0gVlNQMV9ETF9NT0RFX0hFQURFUikgewo+IC0JCS8qIEZpbGwgdGhlIGhlYWRlciBmb3IgdGhl IGhlYWQgYW5kIGNoYWluZWQgZGlzcGxheSBsaXN0cy4gKi8KPiAtCQl2c3AxX2RsX2xpc3RfZmls bF9oZWFkZXIoZGwsIGxpc3RfZW1wdHkoJmRsLT5jaGFpbikpOwo+ICsJLyogRmlsbCB0aGUgaGVh ZGVyIGZvciB0aGUgaGVhZCBhbmQgY2hhaW5lZCBkaXNwbGF5IGxpc3RzLiAqLwo+ICsJdnNwMV9k bF9saXN0X2ZpbGxfaGVhZGVyKGRsLCBsaXN0X2VtcHR5KCZkbC0+Y2hhaW4pKTsKPiAKPiAtCQls aXN0X2Zvcl9lYWNoX2VudHJ5KGRsX25leHQsICZkbC0+Y2hhaW4sIGNoYWluKSB7Cj4gLQkJCWJv b2wgbGFzdCA9IGxpc3RfaXNfbGFzdCgmZGxfbmV4dC0+Y2hhaW4sICZkbC0+Y2hhaW4pOwo+ICsJ bGlzdF9mb3JfZWFjaF9lbnRyeShkbF9uZXh0LCAmZGwtPmNoYWluLCBjaGFpbikgewo+ICsJCWJv b2wgbGFzdCA9IGxpc3RfaXNfbGFzdCgmZGxfbmV4dC0+Y2hhaW4sICZkbC0+Y2hhaW4pOwo+IAo+ IC0JCQl2c3AxX2RsX2xpc3RfZmlsbF9oZWFkZXIoZGxfbmV4dCwgbGFzdCk7Cj4gLQkJfQo+ICsJ CXZzcDFfZGxfbGlzdF9maWxsX2hlYWRlcihkbF9uZXh0LCBsYXN0KTsKPiAgCX0KPiAKPiAgCWRs LT5pbnRlcm5hbCA9IGludGVybmFsOwo+IEBAIC03ODMsMTMgKzc0MSw2IEBAIHZvaWQgdnNwMV9k bG1fc2V0dXAoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxKQo+IAo+ICAJCSB8IFZJNl9ETF9DVFJM X0RDMiB8IFZJNl9ETF9DVFJMX0RDMSB8IFZJNl9ETF9DVFJMX0RDMAo+ICAJCSB8IFZJNl9ETF9D VFJMX0RMRTsKPiAKPiAtCS8qCj4gLQkgKiBUaGUgRFJNIHBpcGVsaW5lIG9wZXJhdGVzIHdpdGgg ZGlzcGxheSBsaXN0cyBpbiBDb250aW51b3VzIEZyYW1lCj4gLQkgKiBNb2RlLCBhbGwgb3RoZXIg cGlwZWxpbmVzIHVzZSBtYW51YWwgc3RhcnQuCj4gLQkgKi8KPiAtCWlmICh2c3AxLT5kcm0pCj4g LQkJY3RybCB8PSBWSTZfRExfQ1RSTF9DRk0wIHwgVkk2X0RMX0NUUkxfTkgwOwo+IC0KPiAgCXZz cDFfd3JpdGUodnNwMSwgVkk2X0RMX0NUUkwsIGN0cmwpOwo+ICAJdnNwMV93cml0ZSh2c3AxLCBW STZfRExfU1dBUCwgVkk2X0RMX1NXQVBfTFdTKTsKPiAgfQo+IEBAIC04MjQsOCArNzc1LDYgQEAg c3RydWN0IHZzcDFfZGxfbWFuYWdlciAqdnNwMV9kbG1fY3JlYXRlKHN0cnVjdAo+IHZzcDFfZGV2 aWNlICp2c3AxLCByZXR1cm4gTlVMTDsKPiAKPiAgCWRsbS0+aW5kZXggPSBpbmRleDsKPiAtCWRs bS0+bW9kZSA9IGluZGV4ID09IDAgJiYgIXZzcDEtPmluZm8tPnVhcGkKPiAtCQkgID8gVlNQMV9E TF9NT0RFX0hFQURFUkxFU1MgOiBWU1AxX0RMX01PREVfSEVBREVSOwo+ICAJZGxtLT5zaW5nbGVz aG90ID0gdnNwMS0+aW5mby0+dWFwaTsKPiAgCWRsbS0+dnNwMSA9IHZzcDE7Cj4gCj4gQEAgLTgz NCwxMyArNzgzLDExIEBAIHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKnZzcDFfZGxtX2NyZWF0ZShz dHJ1Y3QKPiB2c3AxX2RldmljZSAqdnNwMSwKPiAKPiAgCS8qCj4gIAkgKiBJbml0aWFsaXplIHRo ZSBkaXNwbGF5IGxpc3QgYm9keSBhbmQgYWxsb2NhdGUgRE1BIG1lbW9yeSBmb3IgdGhlIGJvZHkK PiAtCSAqIGFuZCB0aGUgb3B0aW9uYWwgaGVhZGVyLiBCb3RoIGFyZSBhbGxvY2F0ZWQgdG9nZXRo ZXIgdG8gYXZvaWQgbWVtb3J5Cj4gKwkgKiBhbmQgdGhlIGhlYWRlci4gQm90aCBhcmUgYWxsb2Nh dGVkIHRvZ2V0aGVyIHRvIGF2b2lkIG1lbW9yeQo+ICAJICogZnJhZ21lbnRhdGlvbiwgd2l0aCB0 aGUgaGVhZGVyIGxvY2F0ZWQgcmlnaHQgYWZ0ZXIgdGhlIGJvZHkgaW4KPiAgCSAqIG1lbW9yeS4K PiAgCSAqLwo+IC0JaGVhZGVyX3NpemUgPSBkbG0tPm1vZGUgPT0gVlNQMV9ETF9NT0RFX0hFQURF Ugo+IC0JCSAgICA/IEFMSUdOKHNpemVvZihzdHJ1Y3QgdnNwMV9kbF9oZWFkZXIpLCA4KQo+IC0J CSAgICA6IDA7Cj4gKwloZWFkZXJfc2l6ZSA9IEFMSUdOKHNpemVvZihzdHJ1Y3QgdnNwMV9kbF9o ZWFkZXIpLCA4KTsKPiAKPiAgCWRsbS0+cG9vbCA9IHZzcDFfZGxfYm9keV9wb29sX2NyZWF0ZSh2 c3AxLCBwcmVhbGxvYywKPiAgCQkJCQkgICAgIFZTUDFfRExfTlVNX0VOVFJJRVMsIGhlYWRlcl9z aXplKTsKCldoaWxlIGF0IGl0LCBjb3VsZCB5b3UgdXBkYXRlIHRoZSBkb2N1bWVudGF0aW9uIG9m IHRoZSAKdnNwMV9kbG1faXJxX2ZyYW1lX2VuZCgpIGZ1bmN0aW9uIHRvIHMvaGVhZGVyIG1vZGUv c2luZ2xlLXNob3QgbW9kZS8gPwoKV2l0aCB0aGVzZSBzbWFsbCBpc3N1ZXMgZml4ZWQsCgpSZXZp ZXdlZC1ieTogTGF1cmVudCBQaW5jaGFydCA8bGF1cmVudC5waW5jaGFydEBpZGVhc29uYm9hcmQu Y29tPgoKLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0CgoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=