From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 99828C47087 for ; Fri, 28 May 2021 07:44:14 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7369361378 for ; Fri, 28 May 2021 07:44:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233980AbhE1Hpq (ORCPT ); Fri, 28 May 2021 03:45:46 -0400 Received: from bhuna.collabora.co.uk ([46.235.227.227]:33170 "EHLO bhuna.collabora.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230133AbhE1Hpg (ORCPT ); Fri, 28 May 2021 03:45:36 -0400 Received: from [IPv6:2a00:a040:193:3500:ed56:60fb:a74f:177d] (unknown [IPv6:2a00:a040:193:3500:ed56:60fb:a74f:177d]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: dafna) by bhuna.collabora.co.uk (Postfix) with ESMTPSA id 760411F41EBF; Fri, 28 May 2021 08:43:58 +0100 (BST) Subject: Re: [PATCH v5 05/14] media: mtk-vcodec: venc: support START and STOP commands From: Dafna Hirschfeld To: Alexandre Courbot Cc: Tiffany Lin , Andrew-CT Chen , Hans Verkuil , Yunfei Dong , Mauro Carvalho Chehab , linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mediatek@lists.infradead.org, Hsin-Yi Wang References: <20210519143011.1175546-1-acourbot@chromium.org> <20210519143011.1175546-6-acourbot@chromium.org> <9b37044d-f909-9169-3d22-fa6c5f788822@collabora.com> Message-ID: <082ffa69-1280-f5e8-f8ef-a1bb6d2bc8c5@collabora.com> Date: Fri, 28 May 2021 10:43:55 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <9b37044d-f909-9169-3d22-fa6c5f788822@collabora.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, On 28.05.21 10:03, Dafna Hirschfeld wrote: > Hi, > > I applied this patchset and tested the stateful encoder on debian with the command: > > [gst-master] root@debian:~/gst-build# gst-launch-1.0 filesrc location=images/jelly-800-640.YU12 ! rawvideoparse width=800 height=640 format=i420 ! videoconvert ! v4l2h264enc ! h264parse ! mp4mux ! filesink location=jelly-800-640.mp4 > > I get: > > Setting pipeline[   79.703879] [MTK_V4L2] level=0 fops_vcodec_open(),190: encoder capability 10000000 >  to PAUSED ... > Pipeline is PREROLLING ... > Redistribute latency... > [   80.621076] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.631232] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.640878] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.650766] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.660430] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.670194] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.680967] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.691376] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.701718] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.712106] mtk-iommu 10205000.iommu: Partial TLB flush timed out, falling back to full flush > [   80.722272] [MTK_V4L2] level=0 mtk_venc_set_param(),371: fmt 0x3, P/L 0/0, w/h 800/640, buf 800/640, fps/bps 25/4000000, gop 0, i_period 0 > Pipeline is PREROLLED ... > Setting pipeline to PLAYING ... > New clock: GstSystemClock > [   81.918747] [MTK_V4L2][ERROR] mtk_vcodec_wait_for_done_ctx:32: [3] ctx->type=1, cmd=1, wait_event_interruptible_timeout time=1000ms out 0 0! > [   81.931392] [MTK_VCODEC][ERROR][3]: h264_encode_frame() irq_status=0 failed > [   81.938470] [MTK_V4L2][ERROR] mtk_venc_worker:1219: venc_if_encode failed=-5 > [   82.974746] [MTK_V4L2][ERROR] mtk_vcodec_wait_for_done_ctx:32: [3] ctx->type=1, cmd=1, wait_event_interruptible_timeout time=1000ms out 0 0! > [   82.987392] [MTK_VCODEC][ERROR][3]: h264_encode_frame() irq_status=0 failed > [   82.994471] [MTK_V4L2][ERROR] mtk_venc_worker:1219: venc_if_encode failed=-5 > [  104.163977] cros-ec-dev cros-ec-dev.2.auto: Some logs may have been dropped... > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > 0:00:00.4 / 99:99:99. > ^Chandling interrupt. > > And then the streaming hangs. The same error happens without this patchset, but without > this patchset the statful encoder does not support V4L2_ENC_CMD_STOP/START needed by the spec. > I am not sure what cause the error and wether those mtk-iommu erros has to do with that. The issue > could also come from the mtk-vpu used by the encoder. > Do you have any idea where this can come from? > > Thanks, > Dafna > > > > On 19.05.21 17:30, Alexandre Courbot wrote: >> The V4L2 encoder specification requires encoders to support the >> V4L2_ENC_CMD_START and V4L2_ENC_CMD_STOP commands. Add support for these >> to the mtk-vcodec encoder by reusing the same flush buffer as used by >> the decoder driver. >> >> Signed-off-by: Alexandre Courbot >> [hsinyi: fix double-free issue if flush buffer was not dequeued by the >> time streamoff is called] >> Signed-off-by: Hsin-Yi Wang >> --- >>   .../platform/mtk-vcodec/mtk_vcodec_drv.h      |   2 + >>   .../platform/mtk-vcodec/mtk_vcodec_enc.c      | 135 +++++++++++++++++- >>   .../platform/mtk-vcodec/mtk_vcodec_enc_drv.c  |   4 + >>   3 files changed, 134 insertions(+), 7 deletions(-) >> >> diff --git a/drivers/media/platform/mtk-vcodec/mtk_vcodec_drv.h b/drivers/media/platform/mtk-vcodec/mtk_vcodec_drv.h >> index c6fe61253f43..37a62c0f406f 100644 >> --- a/drivers/media/platform/mtk-vcodec/mtk_vcodec_drv.h >> +++ b/drivers/media/platform/mtk-vcodec/mtk_vcodec_drv.h >> @@ -252,6 +252,7 @@ struct vdec_pic_info { >>    * @last_decoded_picinfo: pic information get from latest decode >>    * @empty_flush_buf: a fake size-0 capture buffer that indicates flush. Only >>    *             to be used with encoder and stateful decoder. >> + * @is_flushing: set to true if flushing is in progress. >>    * >>    * @colorspace: enum v4l2_colorspace; supplemental to pixelformat >>    * @ycbcr_enc: enum v4l2_ycbcr_encoding, Y'CbCr encoding >> @@ -290,6 +291,7 @@ struct mtk_vcodec_ctx { >>       struct work_struct encode_work; >>       struct vdec_pic_info last_decoded_picinfo; >>       struct v4l2_m2m_buffer empty_flush_buf; >> +    bool is_flushing; >>       enum v4l2_colorspace colorspace; >>       enum v4l2_ycbcr_encoding ycbcr_enc; >> diff --git a/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc.c b/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc.c >> index 4831052f475d..4701dea251ca 100644 >> --- a/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc.c >> +++ b/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc.c >> @@ -659,6 +659,7 @@ static int vidioc_venc_dqbuf(struct file *file, void *priv, >>                    struct v4l2_buffer *buf) >>   { >>       struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv); >> +    int ret; >>       if (ctx->state == MTK_STATE_ABORT) { >>           mtk_v4l2_err("[%d] Call on QBUF after unrecoverable error", >> @@ -666,7 +667,77 @@ static int vidioc_venc_dqbuf(struct file *file, void *priv, >>           return -EIO; >>       } >> -    return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf); >> +    ret = v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf); >> +    if (ret) >> +        return ret; >> + >> +    /* >> +     * Complete flush if the user dequeued the 0-payload LAST buffer. >> +     * We check the payload because a buffer with the LAST flag can also >> +     * be seen during resolution changes. If we happen to be flushing at >> +     * that time, the last buffer before the resolution changes could be >> +     * misinterpreted for the buffer generated by the flush and terminate >> +     * it earlier than we want. >> +     */ >> +    if (!V4L2_TYPE_IS_OUTPUT(buf->type) && >> +        buf->flags & V4L2_BUF_FLAG_LAST && >> +        buf->m.planes[0].bytesused == 0 && >> +        ctx->is_flushing) { >> +        /* >> +         * Last CAPTURE buffer is dequeued, we can allow another flush >> +         * to take place. >> +         */ >> +        ctx->is_flushing = false; >> +    } >> + >> +    return 0; >> +} >> + >> +static int vidioc_encoder_cmd(struct file *file, void *priv, >> +                  struct v4l2_encoder_cmd *cmd) >> +{ >> +    struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv); >> +    struct vb2_queue *src_vq, *dst_vq; >> +    int ret; I see that the driver return -EIO on the ioctls when in state MTK_STATE_ABORT so you should probably test the state here as well. Thanks, Dafna >> + >> +    ret = v4l2_m2m_ioctl_try_encoder_cmd(file, priv, cmd); >> +    if (ret) >> +        return ret; >> + >> +    /* Calling START or STOP is invalid if a flush is in progress */ >> +    if (ctx->is_flushing) >> +        return -EBUSY; >> + >> +    mtk_v4l2_debug(1, "encoder cmd=%u", cmd->cmd); >> + >> +    dst_vq = v4l2_m2m_get_vq(ctx->m2m_ctx, >> +                V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); >> +    switch (cmd->cmd) { >> +    case V4L2_ENC_CMD_STOP: >> +        src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx, >> +                V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); >> +        if (!vb2_is_streaming(src_vq)) { >> +            mtk_v4l2_debug(1, "Output stream is off. No need to flush."); >> +            return 0; >> +        } >> +        if (!vb2_is_streaming(dst_vq)) { >> +            mtk_v4l2_debug(1, "Capture stream is off. No need to flush."); >> +            return 0; >> +        } >> +        ctx->is_flushing = true; >> +        v4l2_m2m_buf_queue(ctx->m2m_ctx, &ctx->empty_flush_buf.vb); >> +        v4l2_m2m_try_schedule(ctx->m2m_ctx); >> +        break; >> + >> +    case V4L2_ENC_CMD_START: >> +        vb2_clear_last_buffer_dequeued(dst_vq); >> +        break; >> + >> +    default: >> +        return -EINVAL; >> +    } >> + >> +    return 0; >>   } >>   const struct v4l2_ioctl_ops mtk_venc_ioctl_ops = { >> @@ -702,6 +773,9 @@ const struct v4l2_ioctl_ops mtk_venc_ioctl_ops = { >>       .vidioc_g_selection        = vidioc_venc_g_selection, >>       .vidioc_s_selection        = vidioc_venc_s_selection, >> + >> +    .vidioc_encoder_cmd        = vidioc_encoder_cmd, >> +    .vidioc_try_encoder_cmd        = v4l2_m2m_ioctl_try_encoder_cmd, >>   }; >>   static int vb2ops_venc_queue_setup(struct vb2_queue *vq, >> @@ -869,9 +943,39 @@ static void vb2ops_venc_stop_streaming(struct vb2_queue *q) >>               dst_buf->vb2_buf.planes[0].bytesused = 0; >>               v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR); >>           } >> +        /* STREAMOFF on the CAPTURE queue completes any ongoing flush */ >> +        if (ctx->is_flushing) { >> +            struct v4l2_m2m_buffer *b, *n; >> + >> +            mtk_v4l2_debug(1, "STREAMOFF called while flushing"); >> +            /* >> +             * STREAMOFF could be called before the flush buffer is >> +             * dequeued. Check whether empty flush buf is still in >> +             * queue before removing it. >> +             */ >> +            v4l2_m2m_for_each_src_buf_safe(ctx->m2m_ctx, b, n) { >> +                if (b == &ctx->empty_flush_buf) { >> +                    v4l2_m2m_src_buf_remove_by_buf( >> +                            ctx->m2m_ctx, &b->vb); >> +                    break; >> +                } >> +            } >> +            ctx->is_flushing = false; >> +        } >>       } else { >> -        while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) >> -            v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR); >> +        while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) { >> +            if (src_buf != &ctx->empty_flush_buf.vb) >> +                v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR); >> +        } >> +        if (ctx->is_flushing) { >> +            /* >> +             * If we are in the middle of a flush, put the flush >> +             * buffer back into the queue so the next CAPTURE >> +             * buffer gets returned with the LAST flag set. >> +             */ >> +            v4l2_m2m_buf_queue(ctx->m2m_ctx, >> +                       &ctx->empty_flush_buf.vb); >> +        } >>       } >>       if ((q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE && >> @@ -971,12 +1075,15 @@ static int mtk_venc_param_change(struct mtk_vcodec_ctx *ctx) >>   { >>       struct venc_enc_param enc_prm; >>       struct vb2_v4l2_buffer *vb2_v4l2 = v4l2_m2m_next_src_buf(ctx->m2m_ctx); >> -    struct mtk_video_enc_buf *mtk_buf = >> -            container_of(vb2_v4l2, struct mtk_video_enc_buf, >> -                     m2m_buf.vb); >> - >> +    struct mtk_video_enc_buf *mtk_buf; >>       int ret = 0; >> +    /* Don't upcast the empty flush buffer */ >> +    if (vb2_v4l2 == &ctx->empty_flush_buf.vb) >> +        return 0; >> + >> +    mtk_buf = container_of(vb2_v4l2, struct mtk_video_enc_buf, m2m_buf.vb); >> + >>       memset(&enc_prm, 0, sizeof(enc_prm)); >>       if (mtk_buf->param_change == MTK_ENCODE_PARAM_NONE) >>           return 0; >> @@ -1062,6 +1169,20 @@ static void mtk_venc_worker(struct work_struct *work) >>       } >>       src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx); >> + >> +    /* >> +     * If we see the flush buffer, send an empty buffer with the LAST flag >> +     * to the client. is_flushing will be reset at the time the buffer >> +     * is dequeued. >> +     */ >> +    if (src_buf == &ctx->empty_flush_buf.vb) { >> +        vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0); >> +        dst_buf->flags |= V4L2_BUF_FLAG_LAST; >> +        v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE); >> +        v4l2_m2m_job_finish(ctx->dev->m2m_dev_enc, ctx->m2m_ctx); >> +        return; >> +    } >> + >>       memset(&frm_buf, 0, sizeof(frm_buf)); >>       for (i = 0; i < src_buf->vb2_buf.num_planes ; i++) { >>           frm_buf.fb_addr[i].dma_addr = >> diff --git a/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c b/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c >> index 7d7b8cfc2cc5..2dd6fef896df 100644 >> --- a/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c >> +++ b/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c >> @@ -131,6 +131,7 @@ static int fops_vcodec_open(struct file *file) >>       struct mtk_vcodec_dev *dev = video_drvdata(file); >>       struct mtk_vcodec_ctx *ctx = NULL; >>       int ret = 0; >> +    struct vb2_queue *src_vq; >>       ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); >>       if (!ctx) >> @@ -164,6 +165,9 @@ static int fops_vcodec_open(struct file *file) >>                   ret); >>           goto err_m2m_ctx_init; >>       } >> +    src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx, >> +                V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); >> +    ctx->empty_flush_buf.vb.vb2_buf.vb2_queue = src_vq; >>       mtk_vcodec_enc_set_default_params(ctx); >>       if (v4l2_fh_is_singular(&ctx->fh)) { >> From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.6 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B7E59C4708C for ; Fri, 28 May 2021 07:44:15 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 5A37061378 for ; Fri, 28 May 2021 07:44:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5A37061378 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=collabora.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:References: Cc:To:From:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=ORNw44HpEJIEKfgJZtoDTcZ20Iqv3nXldzcLOtZ+IRg=; b=0W9E+A1m3JhSAF3Ftx0S3m0WCn MPYn/r2/YCaHvpA0A+Svkl/LKuK95iv/795GXO72j1GmG12aL5j6U6+y/7ejZKa5oYF30/4xcwvqM Qe9kH/AHHh7DUV/emlrohlbGtaEc8ilB/8zeiNNicCHucijvGexnhm98RV+Ta93nfStzImVh5cUK2 y5H96Ba9nqHR1n3EKJh2ndlkmFcCYDscEP0fzL48r13KyOmDTW8umzDWuh+CbJCN7jFl8RLSWCFCg YRHHsIWGaYs4eThOoBNrOH2AtgmsryQ/+JLxWBiEreP7hWp8rvNjwIYbZo6pPVb6NyEdFZx3W+4rK ouU50MVQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1lmXA5-00D7mq-2g; Fri, 28 May 2021 07:44:05 +0000 Received: from bhuna.collabora.co.uk ([2a00:1098:0:82:1000:25:2eeb:e3e3]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1lmXA0-00D7kl-Or for linux-mediatek@lists.infradead.org; Fri, 28 May 2021 07:44:03 +0000 Received: from [IPv6:2a00:a040:193:3500:ed56:60fb:a74f:177d] (unknown [IPv6:2a00:a040:193:3500:ed56:60fb:a74f:177d]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: dafna) by bhuna.collabora.co.uk (Postfix) with ESMTPSA id 760411F41EBF; Fri, 28 May 2021 08:43:58 +0100 (BST) Subject: Re: [PATCH v5 05/14] media: mtk-vcodec: venc: support START and STOP commands From: Dafna Hirschfeld To: Alexandre Courbot Cc: Tiffany Lin , Andrew-CT Chen , Hans Verkuil , Yunfei Dong , Mauro Carvalho Chehab , linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mediatek@lists.infradead.org, Hsin-Yi Wang References: <20210519143011.1175546-1-acourbot@chromium.org> <20210519143011.1175546-6-acourbot@chromium.org> <9b37044d-f909-9169-3d22-fa6c5f788822@collabora.com> Message-ID: <082ffa69-1280-f5e8-f8ef-a1bb6d2bc8c5@collabora.com> Date: Fri, 28 May 2021 10:43:55 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <9b37044d-f909-9169-3d22-fa6c5f788822@collabora.com> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210528_004401_106310_950DBA43 X-CRM114-Status: GOOD ( 43.35 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org SGksCgoKT24gMjguMDUuMjEgMTA6MDMsIERhZm5hIEhpcnNjaGZlbGQgd3JvdGU6Cj4gSGksCj4g Cj4gSSBhcHBsaWVkIHRoaXMgcGF0Y2hzZXQgYW5kIHRlc3RlZCB0aGUgc3RhdGVmdWwgZW5jb2Rl ciBvbiBkZWJpYW4gd2l0aCB0aGUgY29tbWFuZDoKPiAKPiBbZ3N0LW1hc3Rlcl0gcm9vdEBkZWJp YW46fi9nc3QtYnVpbGQjIGdzdC1sYXVuY2gtMS4wIGZpbGVzcmMgbG9jYXRpb249aW1hZ2VzL2pl bGx5LTgwMC02NDAuWVUxMiAhIHJhd3ZpZGVvcGFyc2Ugd2lkdGg9ODAwIGhlaWdodD02NDAgZm9y bWF0PWk0MjAgISB2aWRlb2NvbnZlcnQgISB2NGwyaDI2NGVuYyAhIGgyNjRwYXJzZSAhIG1wNG11 eCAhIGZpbGVzaW5rIGxvY2F0aW9uPWplbGx5LTgwMC02NDAubXA0Cj4gCj4gSSBnZXQ6Cj4gCj4g U2V0dGluZyBwaXBlbGluZVvCoMKgIDc5LjcwMzg3OV0gW01US19WNEwyXSBsZXZlbD0wIGZvcHNf dmNvZGVjX29wZW4oKSwxOTA6IGVuY29kZXIgY2FwYWJpbGl0eSAxMDAwMDAwMAo+ICDCoHRvIFBB VVNFRCAuLi4KPiBQaXBlbGluZSBpcyBQUkVST0xMSU5HIC4uLgo+IFJlZGlzdHJpYnV0ZSBsYXRl bmN5Li4uCj4gW8KgwqAgODAuNjIxMDc2XSBtdGstaW9tbXUgMTAyMDUwMDAuaW9tbXU6IFBhcnRp YWwgVExCIGZsdXNoIHRpbWVkIG91dCwgZmFsbGluZyBiYWNrIHRvIGZ1bGwgZmx1c2gKPiBbwqDC oCA4MC42MzEyMzJdIG10ay1pb21tdSAxMDIwNTAwMC5pb21tdTogUGFydGlhbCBUTEIgZmx1c2gg dGltZWQgb3V0LCBmYWxsaW5nIGJhY2sgdG8gZnVsbCBmbHVzaAo+IFvCoMKgIDgwLjY0MDg3OF0g bXRrLWlvbW11IDEwMjA1MDAwLmlvbW11OiBQYXJ0aWFsIFRMQiBmbHVzaCB0aW1lZCBvdXQsIGZh bGxpbmcgYmFjayB0byBmdWxsIGZsdXNoCj4gW8KgwqAgODAuNjUwNzY2XSBtdGstaW9tbXUgMTAy MDUwMDAuaW9tbXU6IFBhcnRpYWwgVExCIGZsdXNoIHRpbWVkIG91dCwgZmFsbGluZyBiYWNrIHRv IGZ1bGwgZmx1c2gKPiBbwqDCoCA4MC42NjA0MzBdIG10ay1pb21tdSAxMDIwNTAwMC5pb21tdTog UGFydGlhbCBUTEIgZmx1c2ggdGltZWQgb3V0LCBmYWxsaW5nIGJhY2sgdG8gZnVsbCBmbHVzaAo+ IFvCoMKgIDgwLjY3MDE5NF0gbXRrLWlvbW11IDEwMjA1MDAwLmlvbW11OiBQYXJ0aWFsIFRMQiBm bHVzaCB0aW1lZCBvdXQsIGZhbGxpbmcgYmFjayB0byBmdWxsIGZsdXNoCj4gW8KgwqAgODAuNjgw OTY3XSBtdGstaW9tbXUgMTAyMDUwMDAuaW9tbXU6IFBhcnRpYWwgVExCIGZsdXNoIHRpbWVkIG91 dCwgZmFsbGluZyBiYWNrIHRvIGZ1bGwgZmx1c2gKPiBbwqDCoCA4MC42OTEzNzZdIG10ay1pb21t dSAxMDIwNTAwMC5pb21tdTogUGFydGlhbCBUTEIgZmx1c2ggdGltZWQgb3V0LCBmYWxsaW5nIGJh Y2sgdG8gZnVsbCBmbHVzaAo+IFvCoMKgIDgwLjcwMTcxOF0gbXRrLWlvbW11IDEwMjA1MDAwLmlv bW11OiBQYXJ0aWFsIFRMQiBmbHVzaCB0aW1lZCBvdXQsIGZhbGxpbmcgYmFjayB0byBmdWxsIGZs dXNoCj4gW8KgwqAgODAuNzEyMTA2XSBtdGstaW9tbXUgMTAyMDUwMDAuaW9tbXU6IFBhcnRpYWwg VExCIGZsdXNoIHRpbWVkIG91dCwgZmFsbGluZyBiYWNrIHRvIGZ1bGwgZmx1c2gKPiBbwqDCoCA4 MC43MjIyNzJdIFtNVEtfVjRMMl0gbGV2ZWw9MCBtdGtfdmVuY19zZXRfcGFyYW0oKSwzNzE6IGZt dCAweDMsIFAvTCAwLzAsIHcvaCA4MDAvNjQwLCBidWYgODAwLzY0MCwgZnBzL2JwcyAyNS80MDAw MDAwLCBnb3AgMCwgaV9wZXJpb2QgMAo+IFBpcGVsaW5lIGlzIFBSRVJPTExFRCAuLi4KPiBTZXR0 aW5nIHBpcGVsaW5lIHRvIFBMQVlJTkcgLi4uCj4gTmV3IGNsb2NrOiBHc3RTeXN0ZW1DbG9jawo+ IFvCoMKgIDgxLjkxODc0N10gW01US19WNEwyXVtFUlJPUl0gbXRrX3Zjb2RlY193YWl0X2Zvcl9k b25lX2N0eDozMjogWzNdIGN0eC0+dHlwZT0xLCBjbWQ9MSwgd2FpdF9ldmVudF9pbnRlcnJ1cHRp YmxlX3RpbWVvdXQgdGltZT0xMDAwbXMgb3V0IDAgMCEKPiBbwqDCoCA4MS45MzEzOTJdIFtNVEtf VkNPREVDXVtFUlJPUl1bM106IGgyNjRfZW5jb2RlX2ZyYW1lKCkgaXJxX3N0YXR1cz0wIGZhaWxl ZAo+IFvCoMKgIDgxLjkzODQ3MF0gW01US19WNEwyXVtFUlJPUl0gbXRrX3ZlbmNfd29ya2VyOjEy MTk6IHZlbmNfaWZfZW5jb2RlIGZhaWxlZD0tNQo+IFvCoMKgIDgyLjk3NDc0Nl0gW01US19WNEwy XVtFUlJPUl0gbXRrX3Zjb2RlY193YWl0X2Zvcl9kb25lX2N0eDozMjogWzNdIGN0eC0+dHlwZT0x LCBjbWQ9MSwgd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlX3RpbWVvdXQgdGltZT0xMDAwbXMgb3V0 IDAgMCEKPiBbwqDCoCA4Mi45ODczOTJdIFtNVEtfVkNPREVDXVtFUlJPUl1bM106IGgyNjRfZW5j b2RlX2ZyYW1lKCkgaXJxX3N0YXR1cz0wIGZhaWxlZAo+IFvCoMKgIDgyLjk5NDQ3MV0gW01US19W NEwyXVtFUlJPUl0gbXRrX3ZlbmNfd29ya2VyOjEyMTk6IHZlbmNfaWZfZW5jb2RlIGZhaWxlZD0t NQo+IFvCoCAxMDQuMTYzOTc3XSBjcm9zLWVjLWRldiBjcm9zLWVjLWRldi4yLmF1dG86IFNvbWUg bG9ncyBtYXkgaGF2ZSBiZWVuIGRyb3BwZWQuLi4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5OS4KPiAw OjAwOjAwLjQgLyA5OTo5OTo5OS4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5OS4KPiAwOjAwOjAwLjQg LyA5OTo5OTo5OS4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5OS4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5 OS4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5OS4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5OS4KPiAwOjAw OjAwLjQgLyA5OTo5OTo5OS4KPiAwOjAwOjAwLjQgLyA5OTo5OTo5OS4KPiBeQ2hhbmRsaW5nIGlu dGVycnVwdC4KPiAKPiBBbmQgdGhlbiB0aGUgc3RyZWFtaW5nIGhhbmdzLiBUaGUgc2FtZSBlcnJv ciBoYXBwZW5zIHdpdGhvdXQgdGhpcyBwYXRjaHNldCwgYnV0IHdpdGhvdXQKPiB0aGlzIHBhdGNo c2V0IHRoZSBzdGF0ZnVsIGVuY29kZXIgZG9lcyBub3Qgc3VwcG9ydCBWNEwyX0VOQ19DTURfU1RP UC9TVEFSVCBuZWVkZWQgYnkgdGhlIHNwZWMuCj4gSSBhbSBub3Qgc3VyZSB3aGF0IGNhdXNlIHRo ZSBlcnJvciBhbmQgd2V0aGVyIHRob3NlIG10ay1pb21tdSBlcnJvcyBoYXMgdG8gZG8gd2l0aCB0 aGF0LiBUaGUgaXNzdWUKPiBjb3VsZCBhbHNvIGNvbWUgZnJvbSB0aGUgbXRrLXZwdSB1c2VkIGJ5 IHRoZSBlbmNvZGVyLgo+IERvIHlvdSBoYXZlIGFueSBpZGVhIHdoZXJlIHRoaXMgY2FuIGNvbWUg ZnJvbT8KPiAKPiBUaGFua3MsCj4gRGFmbmEKPiAKPiAKPiAKPiBPbiAxOS4wNS4yMSAxNzozMCwg QWxleGFuZHJlIENvdXJib3Qgd3JvdGU6Cj4+IFRoZSBWNEwyIGVuY29kZXIgc3BlY2lmaWNhdGlv biByZXF1aXJlcyBlbmNvZGVycyB0byBzdXBwb3J0IHRoZQo+PiBWNEwyX0VOQ19DTURfU1RBUlQg YW5kIFY0TDJfRU5DX0NNRF9TVE9QIGNvbW1hbmRzLiBBZGQgc3VwcG9ydCBmb3IgdGhlc2UKPj4g dG8gdGhlIG10ay12Y29kZWMgZW5jb2RlciBieSByZXVzaW5nIHRoZSBzYW1lIGZsdXNoIGJ1ZmZl ciBhcyB1c2VkIGJ5Cj4+IHRoZSBkZWNvZGVyIGRyaXZlci4KPj4KPj4gU2lnbmVkLW9mZi1ieTog QWxleGFuZHJlIENvdXJib3QgPGFjb3VyYm90QGNocm9taXVtLm9yZz4KPj4gW2hzaW55aTogZml4 IGRvdWJsZS1mcmVlIGlzc3VlIGlmIGZsdXNoIGJ1ZmZlciB3YXMgbm90IGRlcXVldWVkIGJ5IHRo ZQo+PiB0aW1lIHN0cmVhbW9mZiBpcyBjYWxsZWRdCj4+IFNpZ25lZC1vZmYtYnk6IEhzaW4tWWkg V2FuZyA8aHNpbnlpQGNocm9taXVtLm9yZz4KPj4gLS0tCj4+IMKgIC4uLi9wbGF0Zm9ybS9tdGst dmNvZGVjL210a192Y29kZWNfZHJ2LmjCoMKgwqDCoMKgIHzCoMKgIDIgKwo+PiDCoCAuLi4vcGxh dGZvcm0vbXRrLXZjb2RlYy9tdGtfdmNvZGVjX2VuYy5jwqDCoMKgwqDCoCB8IDEzNSArKysrKysr KysrKysrKysrKy0KPj4gwqAgLi4uL3BsYXRmb3JtL210ay12Y29kZWMvbXRrX3Zjb2RlY19lbmNf ZHJ2LmPCoCB8wqDCoCA0ICsKPj4gwqAgMyBmaWxlcyBjaGFuZ2VkLCAxMzQgaW5zZXJ0aW9ucygr KSwgNyBkZWxldGlvbnMoLSkKPj4KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vbXRrLXZjb2RlYy9tdGtfdmNvZGVjX2Rydi5oIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9t dGstdmNvZGVjL210a192Y29kZWNfZHJ2LmgKPj4gaW5kZXggYzZmZTYxMjUzZjQzLi4zN2E2MmMw ZjQwNmYgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLXZjb2RlYy9t dGtfdmNvZGVjX2Rydi5oCj4+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLXZjb2Rl Yy9tdGtfdmNvZGVjX2Rydi5oCj4+IEBAIC0yNTIsNiArMjUyLDcgQEAgc3RydWN0IHZkZWNfcGlj X2luZm8gewo+PiDCoMKgICogQGxhc3RfZGVjb2RlZF9waWNpbmZvOiBwaWMgaW5mb3JtYXRpb24g Z2V0IGZyb20gbGF0ZXN0IGRlY29kZQo+PiDCoMKgICogQGVtcHR5X2ZsdXNoX2J1ZjogYSBmYWtl IHNpemUtMCBjYXB0dXJlIGJ1ZmZlciB0aGF0IGluZGljYXRlcyBmbHVzaC4gT25seQo+PiDCoMKg ICrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdG8gYmUgdXNlZCB3aXRoIGVuY29kZXIgYW5kIHN0 YXRlZnVsIGRlY29kZXIuCj4+ICsgKiBAaXNfZmx1c2hpbmc6IHNldCB0byB0cnVlIGlmIGZsdXNo aW5nIGlzIGluIHByb2dyZXNzLgo+PiDCoMKgICoKPj4gwqDCoCAqIEBjb2xvcnNwYWNlOiBlbnVt IHY0bDJfY29sb3JzcGFjZTsgc3VwcGxlbWVudGFsIHRvIHBpeGVsZm9ybWF0Cj4+IMKgwqAgKiBA eWNiY3JfZW5jOiBlbnVtIHY0bDJfeWNiY3JfZW5jb2RpbmcsIFknQ2JDciBlbmNvZGluZwo+PiBA QCAtMjkwLDYgKzI5MSw3IEBAIHN0cnVjdCBtdGtfdmNvZGVjX2N0eCB7Cj4+IMKgwqDCoMKgwqAg c3RydWN0IHdvcmtfc3RydWN0IGVuY29kZV93b3JrOwo+PiDCoMKgwqDCoMKgIHN0cnVjdCB2ZGVj X3BpY19pbmZvIGxhc3RfZGVjb2RlZF9waWNpbmZvOwo+PiDCoMKgwqDCoMKgIHN0cnVjdCB2NGwy X20ybV9idWZmZXIgZW1wdHlfZmx1c2hfYnVmOwo+PiArwqDCoMKgIGJvb2wgaXNfZmx1c2hpbmc7 Cj4+IMKgwqDCoMKgwqAgZW51bSB2NGwyX2NvbG9yc3BhY2UgY29sb3JzcGFjZTsKPj4gwqDCoMKg wqDCoCBlbnVtIHY0bDJfeWNiY3JfZW5jb2RpbmcgeWNiY3JfZW5jOwo+PiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstdmNvZGVjL210a192Y29kZWNfZW5jLmMgYi9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL210ay12Y29kZWMvbXRrX3Zjb2RlY19lbmMuYwo+PiBpbmRleCA0 ODMxMDUyZjQ3NWQuLjQ3MDFkZWEyNTFjYSAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9tdGstdmNvZGVjL210a192Y29kZWNfZW5jLmMKPj4gKysrIGIvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9tdGstdmNvZGVjL210a192Y29kZWNfZW5jLmMKPj4gQEAgLTY1OSw2ICs2NTks NyBAQCBzdGF0aWMgaW50IHZpZGlvY192ZW5jX2RxYnVmKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lk ICpwcml2LAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RydWN0IHY0 bDJfYnVmZmVyICpidWYpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgbXRrX3Zjb2RlY19j dHggKmN0eCA9IGZoX3RvX2N0eChwcml2KTsKPj4gK8KgwqDCoCBpbnQgcmV0Owo+PiDCoMKgwqDC oMKgIGlmIChjdHgtPnN0YXRlID09IE1US19TVEFURV9BQk9SVCkgewo+PiDCoMKgwqDCoMKgwqDC oMKgwqAgbXRrX3Y0bDJfZXJyKCJbJWRdIENhbGwgb24gUUJVRiBhZnRlciB1bnJlY292ZXJhYmxl IGVycm9yIiwKPj4gQEAgLTY2Niw3ICs2NjcsNzcgQEAgc3RhdGljIGludCB2aWRpb2NfdmVuY19k cWJ1ZihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKPj4gwqDCoMKgwqDCoMKgwqDCoMKg IHJldHVybiAtRUlPOwo+PiDCoMKgwqDCoMKgIH0KPj4gLcKgwqDCoCByZXR1cm4gdjRsMl9tMm1f ZHFidWYoZmlsZSwgY3R4LT5tMm1fY3R4LCBidWYpOwo+PiArwqDCoMKgIHJldCA9IHY0bDJfbTJt X2RxYnVmKGZpbGUsIGN0eC0+bTJtX2N0eCwgYnVmKTsKPj4gK8KgwqDCoCBpZiAocmV0KQo+PiAr wqDCoMKgwqDCoMKgwqAgcmV0dXJuIHJldDsKPj4gKwo+PiArwqDCoMKgIC8qCj4+ICvCoMKgwqDC oCAqIENvbXBsZXRlIGZsdXNoIGlmIHRoZSB1c2VyIGRlcXVldWVkIHRoZSAwLXBheWxvYWQgTEFT VCBidWZmZXIuCj4+ICvCoMKgwqDCoCAqIFdlIGNoZWNrIHRoZSBwYXlsb2FkIGJlY2F1c2UgYSBi dWZmZXIgd2l0aCB0aGUgTEFTVCBmbGFnIGNhbiBhbHNvCj4+ICvCoMKgwqDCoCAqIGJlIHNlZW4g ZHVyaW5nIHJlc29sdXRpb24gY2hhbmdlcy4gSWYgd2UgaGFwcGVuIHRvIGJlIGZsdXNoaW5nIGF0 Cj4+ICvCoMKgwqDCoCAqIHRoYXQgdGltZSwgdGhlIGxhc3QgYnVmZmVyIGJlZm9yZSB0aGUgcmVz b2x1dGlvbiBjaGFuZ2VzIGNvdWxkIGJlCj4+ICvCoMKgwqDCoCAqIG1pc2ludGVycHJldGVkIGZv ciB0aGUgYnVmZmVyIGdlbmVyYXRlZCBieSB0aGUgZmx1c2ggYW5kIHRlcm1pbmF0ZQo+PiArwqDC oMKgwqAgKiBpdCBlYXJsaWVyIHRoYW4gd2Ugd2FudC4KPj4gK8KgwqDCoMKgICovCj4+ICvCoMKg wqAgaWYgKCFWNEwyX1RZUEVfSVNfT1VUUFVUKGJ1Zi0+dHlwZSkgJiYKPj4gK8KgwqDCoMKgwqDC oMKgIGJ1Zi0+ZmxhZ3MgJiBWNEwyX0JVRl9GTEFHX0xBU1QgJiYKPj4gK8KgwqDCoMKgwqDCoMKg IGJ1Zi0+bS5wbGFuZXNbMF0uYnl0ZXN1c2VkID09IDAgJiYKPj4gK8KgwqDCoMKgwqDCoMKgIGN0 eC0+aXNfZmx1c2hpbmcpIHsKPj4gK8KgwqDCoMKgwqDCoMKgIC8qCj4+ICvCoMKgwqDCoMKgwqDC oMKgICogTGFzdCBDQVBUVVJFIGJ1ZmZlciBpcyBkZXF1ZXVlZCwgd2UgY2FuIGFsbG93IGFub3Ro ZXIgZmx1c2gKPj4gK8KgwqDCoMKgwqDCoMKgwqAgKiB0byB0YWtlIHBsYWNlLgo+PiArwqDCoMKg wqDCoMKgwqDCoCAqLwo+PiArwqDCoMKgwqDCoMKgwqAgY3R4LT5pc19mbHVzaGluZyA9IGZhbHNl Owo+PiArwqDCoMKgIH0KPj4gKwo+PiArwqDCoMKgIHJldHVybiAwOwo+PiArfQo+PiArCj4+ICtz dGF0aWMgaW50IHZpZGlvY19lbmNvZGVyX2NtZChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJp diwKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RydWN0IHY0bDJfZW5j b2Rlcl9jbWQgKmNtZCkKPj4gK3sKPj4gK8KgwqDCoCBzdHJ1Y3QgbXRrX3Zjb2RlY19jdHggKmN0 eCA9IGZoX3RvX2N0eChwcml2KTsKPj4gK8KgwqDCoCBzdHJ1Y3QgdmIyX3F1ZXVlICpzcmNfdnEs ICpkc3RfdnE7Cj4+ICvCoMKgwqAgaW50IHJldDsKCkkgc2VlIHRoYXQgdGhlIGRyaXZlciByZXR1 cm4gLUVJTyBvbiB0aGUgaW9jdGxzIHdoZW4gaW4gc3RhdGUgTVRLX1NUQVRFX0FCT1JUCnNvIHlv dSBzaG91bGQgcHJvYmFibHkgdGVzdCB0aGUgc3RhdGUgaGVyZSBhcyB3ZWxsLgoKVGhhbmtzLApE YWZuYQoKPj4gKwo+PiArwqDCoMKgIHJldCA9IHY0bDJfbTJtX2lvY3RsX3RyeV9lbmNvZGVyX2Nt ZChmaWxlLCBwcml2LCBjbWQpOwo+PiArwqDCoMKgIGlmIChyZXQpCj4+ICvCoMKgwqDCoMKgwqDC oCByZXR1cm4gcmV0Owo+PiArCj4+ICvCoMKgwqAgLyogQ2FsbGluZyBTVEFSVCBvciBTVE9QIGlz IGludmFsaWQgaWYgYSBmbHVzaCBpcyBpbiBwcm9ncmVzcyAqLwo+PiArwqDCoMKgIGlmIChjdHgt PmlzX2ZsdXNoaW5nKQo+PiArwqDCoMKgwqDCoMKgwqAgcmV0dXJuIC1FQlVTWTsKPj4gKwo+PiAr wqDCoMKgIG10a192NGwyX2RlYnVnKDEsICJlbmNvZGVyIGNtZD0ldSIsIGNtZC0+Y21kKTsKPj4g Kwo+PiArwqDCoMKgIGRzdF92cSA9IHY0bDJfbTJtX2dldF92cShjdHgtPm0ybV9jdHgsCj4+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgVjRMMl9CVUZfVFlQRV9WSURFT19DQVBUVVJF X01QTEFORSk7Cj4+ICvCoMKgwqAgc3dpdGNoIChjbWQtPmNtZCkgewo+PiArwqDCoMKgIGNhc2Ug VjRMMl9FTkNfQ01EX1NUT1A6Cj4+ICvCoMKgwqDCoMKgwqDCoCBzcmNfdnEgPSB2NGwyX20ybV9n ZXRfdnEoY3R4LT5tMm1fY3R4LAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIFY0 TDJfQlVGX1RZUEVfVklERU9fT1VUUFVUX01QTEFORSk7Cj4+ICvCoMKgwqDCoMKgwqDCoCBpZiAo IXZiMl9pc19zdHJlYW1pbmcoc3JjX3ZxKSkgewo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBt dGtfdjRsMl9kZWJ1ZygxLCAiT3V0cHV0IHN0cmVhbSBpcyBvZmYuIE5vIG5lZWQgdG8gZmx1c2gu Iik7Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiAwOwo+PiArwqDCoMKgwqDCoMKg wqAgfQo+PiArwqDCoMKgwqDCoMKgwqAgaWYgKCF2YjJfaXNfc3RyZWFtaW5nKGRzdF92cSkpIHsK Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbXRrX3Y0bDJfZGVidWcoMSwgIkNhcHR1cmUgc3Ry ZWFtIGlzIG9mZi4gTm8gbmVlZCB0byBmbHVzaC4iKTsKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqAgcmV0dXJuIDA7Cj4+ICvCoMKgwqDCoMKgwqDCoCB9Cj4+ICvCoMKgwqDCoMKgwqDCoCBjdHgt PmlzX2ZsdXNoaW5nID0gdHJ1ZTsKPj4gK8KgwqDCoMKgwqDCoMKgIHY0bDJfbTJtX2J1Zl9xdWV1 ZShjdHgtPm0ybV9jdHgsICZjdHgtPmVtcHR5X2ZsdXNoX2J1Zi52Yik7Cj4+ICvCoMKgwqDCoMKg wqDCoCB2NGwyX20ybV90cnlfc2NoZWR1bGUoY3R4LT5tMm1fY3R4KTsKPj4gK8KgwqDCoMKgwqDC oMKgIGJyZWFrOwo+PiArCj4+ICvCoMKgwqAgY2FzZSBWNEwyX0VOQ19DTURfU1RBUlQ6Cj4+ICvC oMKgwqDCoMKgwqDCoCB2YjJfY2xlYXJfbGFzdF9idWZmZXJfZGVxdWV1ZWQoZHN0X3ZxKTsKPj4g K8KgwqDCoMKgwqDCoMKgIGJyZWFrOwo+PiArCj4+ICvCoMKgwqAgZGVmYXVsdDoKPj4gK8KgwqDC oMKgwqDCoMKgIHJldHVybiAtRUlOVkFMOwo+PiArwqDCoMKgIH0KPj4gKwo+PiArwqDCoMKgIHJl dHVybiAwOwo+PiDCoCB9Cj4+IMKgIGNvbnN0IHN0cnVjdCB2NGwyX2lvY3RsX29wcyBtdGtfdmVu Y19pb2N0bF9vcHMgPSB7Cj4+IEBAIC03MDIsNiArNzczLDkgQEAgY29uc3Qgc3RydWN0IHY0bDJf aW9jdGxfb3BzIG10a192ZW5jX2lvY3RsX29wcyA9IHsKPj4gwqDCoMKgwqDCoCAudmlkaW9jX2df c2VsZWN0aW9uwqDCoMKgwqDCoMKgwqAgPSB2aWRpb2NfdmVuY19nX3NlbGVjdGlvbiwKPj4gwqDC oMKgwqDCoCAudmlkaW9jX3Nfc2VsZWN0aW9uwqDCoMKgwqDCoMKgwqAgPSB2aWRpb2NfdmVuY19z X3NlbGVjdGlvbiwKPj4gKwo+PiArwqDCoMKgIC52aWRpb2NfZW5jb2Rlcl9jbWTCoMKgwqDCoMKg wqDCoCA9IHZpZGlvY19lbmNvZGVyX2NtZCwKPj4gK8KgwqDCoCAudmlkaW9jX3RyeV9lbmNvZGVy X2NtZMKgwqDCoMKgwqDCoMKgID0gdjRsMl9tMm1faW9jdGxfdHJ5X2VuY29kZXJfY21kLAo+PiDC oCB9Owo+PiDCoCBzdGF0aWMgaW50IHZiMm9wc192ZW5jX3F1ZXVlX3NldHVwKHN0cnVjdCB2YjJf cXVldWUgKnZxLAo+PiBAQCAtODY5LDkgKzk0MywzOSBAQCBzdGF0aWMgdm9pZCB2YjJvcHNfdmVu Y19zdG9wX3N0cmVhbWluZyhzdHJ1Y3QgdmIyX3F1ZXVlICpxKQo+PiDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBkc3RfYnVmLT52YjJfYnVmLnBsYW5lc1swXS5ieXRlc3VzZWQgPSAwOwo+PiDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2NGwyX20ybV9idWZfZG9uZShkc3RfYnVmLCBWQjJf QlVGX1NUQVRFX0VSUk9SKTsKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIH0KPj4gK8KgwqDCoMKgwqDC oMKgIC8qIFNUUkVBTU9GRiBvbiB0aGUgQ0FQVFVSRSBxdWV1ZSBjb21wbGV0ZXMgYW55IG9uZ29p bmcgZmx1c2ggKi8KPj4gK8KgwqDCoMKgwqDCoMKgIGlmIChjdHgtPmlzX2ZsdXNoaW5nKSB7Cj4+ ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCB2NGwyX20ybV9idWZmZXIgKmIsICpuOwo+ PiArCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG10a192NGwyX2RlYnVnKDEsICJTVFJFQU1P RkYgY2FsbGVkIHdoaWxlIGZsdXNoaW5nIik7Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIC8q Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKiBTVFJFQU1PRkYgY291bGQgYmUgY2FsbGVk IGJlZm9yZSB0aGUgZmx1c2ggYnVmZmVyIGlzCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg KiBkZXF1ZXVlZC4gQ2hlY2sgd2hldGhlciBlbXB0eSBmbHVzaCBidWYgaXMgc3RpbGwgaW4KPj4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAqIHF1ZXVlIGJlZm9yZSByZW1vdmluZyBpdC4KPj4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAqLwo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2 NGwyX20ybV9mb3JfZWFjaF9zcmNfYnVmX3NhZmUoY3R4LT5tMm1fY3R4LCBiLCBuKSB7Cj4+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWYgKGIgPT0gJmN0eC0+ZW1wdHlfZmx1c2hf YnVmKSB7Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2NGwyX20y bV9zcmNfYnVmX3JlbW92ZV9ieV9idWYoCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY3R4LT5tMm1fY3R4LCAmYi0+dmIpOwo+PiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgYnJlYWs7Cj4+ICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgfQo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB9Cj4+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIGN0eC0+aXNfZmx1c2hpbmcgPSBmYWxzZTsKPj4gK8KgwqDC oMKgwqDCoMKgIH0KPj4gwqDCoMKgwqDCoCB9IGVsc2Ugewo+PiAtwqDCoMKgwqDCoMKgwqAgd2hp bGUgKChzcmNfYnVmID0gdjRsMl9tMm1fc3JjX2J1Zl9yZW1vdmUoY3R4LT5tMm1fY3R4KSkpCj4+ IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHY0bDJfbTJtX2J1Zl9kb25lKHNyY19idWYsIFZCMl9C VUZfU1RBVEVfRVJST1IpOwo+PiArwqDCoMKgwqDCoMKgwqAgd2hpbGUgKChzcmNfYnVmID0gdjRs Ml9tMm1fc3JjX2J1Zl9yZW1vdmUoY3R4LT5tMm1fY3R4KSkpIHsKPj4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqAgaWYgKHNyY19idWYgIT0gJmN0eC0+ZW1wdHlfZmx1c2hfYnVmLnZiKQo+PiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHY0bDJfbTJtX2J1Zl9kb25lKHNyY19idWYsIFZC Ml9CVUZfU1RBVEVfRVJST1IpOwo+PiArwqDCoMKgwqDCoMKgwqAgfQo+PiArwqDCoMKgwqDCoMKg wqAgaWYgKGN0eC0+aXNfZmx1c2hpbmcpIHsKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgLyoK Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAqIElmIHdlIGFyZSBpbiB0aGUgbWlkZGxlIG9m IGEgZmx1c2gsIHB1dCB0aGUgZmx1c2gKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAqIGJ1 ZmZlciBiYWNrIGludG8gdGhlIHF1ZXVlIHNvIHRoZSBuZXh0IENBUFRVUkUKPj4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCAqIGJ1ZmZlciBnZXRzIHJldHVybmVkIHdpdGggdGhlIExBU1QgZmxh ZyBzZXQuCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKi8KPj4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqAgdjRsMl9tMm1fYnVmX3F1ZXVlKGN0eC0+bTJtX2N0eCwKPj4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICZjdHgtPmVtcHR5X2ZsdXNoX2J1Zi52 Yik7Cj4+ICvCoMKgwqDCoMKgwqDCoCB9Cj4+IMKgwqDCoMKgwqAgfQo+PiDCoMKgwqDCoMKgIGlm ICgocS0+dHlwZSA9PSBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkVfTVBMQU5FICYmCj4+IEBA IC05NzEsMTIgKzEwNzUsMTUgQEAgc3RhdGljIGludCBtdGtfdmVuY19wYXJhbV9jaGFuZ2Uoc3Ry dWN0IG10a192Y29kZWNfY3R4ICpjdHgpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgdmVu Y19lbmNfcGFyYW0gZW5jX3BybTsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgdmIyX3Y0bDJfYnVmZmVy ICp2YjJfdjRsMiA9IHY0bDJfbTJtX25leHRfc3JjX2J1ZihjdHgtPm0ybV9jdHgpOwo+PiAtwqDC oMKgIHN0cnVjdCBtdGtfdmlkZW9fZW5jX2J1ZiAqbXRrX2J1ZiA9Cj4+IC3CoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGNvbnRhaW5lcl9vZih2YjJfdjRsMiwgc3RydWN0IG10a192aWRlb19lbmNfYnVm LAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBtMm1fYnVmLnZi KTsKPj4gLQo+PiArwqDCoMKgIHN0cnVjdCBtdGtfdmlkZW9fZW5jX2J1ZiAqbXRrX2J1ZjsKPj4g wqDCoMKgwqDCoCBpbnQgcmV0ID0gMDsKPj4gK8KgwqDCoCAvKiBEb24ndCB1cGNhc3QgdGhlIGVt cHR5IGZsdXNoIGJ1ZmZlciAqLwo+PiArwqDCoMKgIGlmICh2YjJfdjRsMiA9PSAmY3R4LT5lbXB0 eV9mbHVzaF9idWYudmIpCj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gMDsKPj4gKwo+PiArwqDC oMKgIG10a19idWYgPSBjb250YWluZXJfb2YodmIyX3Y0bDIsIHN0cnVjdCBtdGtfdmlkZW9fZW5j X2J1ZiwgbTJtX2J1Zi52Yik7Cj4+ICsKPj4gwqDCoMKgwqDCoCBtZW1zZXQoJmVuY19wcm0sIDAs IHNpemVvZihlbmNfcHJtKSk7Cj4+IMKgwqDCoMKgwqAgaWYgKG10a19idWYtPnBhcmFtX2NoYW5n ZSA9PSBNVEtfRU5DT0RFX1BBUkFNX05PTkUpCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4g MDsKPj4gQEAgLTEwNjIsNiArMTE2OSwyMCBAQCBzdGF0aWMgdm9pZCBtdGtfdmVuY193b3JrZXIo c3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQo+PiDCoMKgwqDCoMKgIH0KPj4gwqDCoMKgwqDCoCBz cmNfYnVmID0gdjRsMl9tMm1fc3JjX2J1Zl9yZW1vdmUoY3R4LT5tMm1fY3R4KTsKPj4gKwo+PiAr wqDCoMKgIC8qCj4+ICvCoMKgwqDCoCAqIElmIHdlIHNlZSB0aGUgZmx1c2ggYnVmZmVyLCBzZW5k IGFuIGVtcHR5IGJ1ZmZlciB3aXRoIHRoZSBMQVNUIGZsYWcKPj4gK8KgwqDCoMKgICogdG8gdGhl IGNsaWVudC4gaXNfZmx1c2hpbmcgd2lsbCBiZSByZXNldCBhdCB0aGUgdGltZSB0aGUgYnVmZmVy Cj4+ICvCoMKgwqDCoCAqIGlzIGRlcXVldWVkLgo+PiArwqDCoMKgwqAgKi8KPj4gK8KgwqDCoCBp ZiAoc3JjX2J1ZiA9PSAmY3R4LT5lbXB0eV9mbHVzaF9idWYudmIpIHsKPj4gK8KgwqDCoMKgwqDC oMKgIHZiMl9zZXRfcGxhbmVfcGF5bG9hZCgmZHN0X2J1Zi0+dmIyX2J1ZiwgMCwgMCk7Cj4+ICvC oMKgwqDCoMKgwqDCoCBkc3RfYnVmLT5mbGFncyB8PSBWNEwyX0JVRl9GTEFHX0xBU1Q7Cj4+ICvC oMKgwqDCoMKgwqDCoCB2NGwyX20ybV9idWZfZG9uZShkc3RfYnVmLCBWQjJfQlVGX1NUQVRFX0RP TkUpOwo+PiArwqDCoMKgwqDCoMKgwqAgdjRsMl9tMm1fam9iX2ZpbmlzaChjdHgtPmRldi0+bTJt X2Rldl9lbmMsIGN0eC0+bTJtX2N0eCk7Cj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm47Cj4+ICvC oMKgwqAgfQo+PiArCj4+IMKgwqDCoMKgwqAgbWVtc2V0KCZmcm1fYnVmLCAwLCBzaXplb2YoZnJt X2J1ZikpOwo+PiDCoMKgwqDCoMKgIGZvciAoaSA9IDA7IGkgPCBzcmNfYnVmLT52YjJfYnVmLm51 bV9wbGFuZXMgOyBpKyspIHsKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIGZybV9idWYuZmJfYWRkcltp XS5kbWFfYWRkciA9Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay12 Y29kZWMvbXRrX3Zjb2RlY19lbmNfZHJ2LmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay12 Y29kZWMvbXRrX3Zjb2RlY19lbmNfZHJ2LmMKPj4gaW5kZXggN2Q3YjhjZmMyY2M1Li4yZGQ2ZmVm ODk2ZGYgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLXZjb2RlYy9t dGtfdmNvZGVjX2VuY19kcnYuYwo+PiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay12 Y29kZWMvbXRrX3Zjb2RlY19lbmNfZHJ2LmMKPj4gQEAgLTEzMSw2ICsxMzEsNyBAQCBzdGF0aWMg aW50IGZvcHNfdmNvZGVjX29wZW4oc3RydWN0IGZpbGUgKmZpbGUpCj4+IMKgwqDCoMKgwqAgc3Ry dWN0IG10a192Y29kZWNfZGV2ICpkZXYgPSB2aWRlb19kcnZkYXRhKGZpbGUpOwo+PiDCoMKgwqDC oMKgIHN0cnVjdCBtdGtfdmNvZGVjX2N0eCAqY3R4ID0gTlVMTDsKPj4gwqDCoMKgwqDCoCBpbnQg cmV0ID0gMDsKPj4gK8KgwqDCoCBzdHJ1Y3QgdmIyX3F1ZXVlICpzcmNfdnE7Cj4+IMKgwqDCoMKg wqAgY3R4ID0ga3phbGxvYyhzaXplb2YoKmN0eCksIEdGUF9LRVJORUwpOwo+PiDCoMKgwqDCoMKg IGlmICghY3R4KQo+PiBAQCAtMTY0LDYgKzE2NSw5IEBAIHN0YXRpYyBpbnQgZm9wc192Y29kZWNf b3BlbihzdHJ1Y3QgZmlsZSAqZmlsZSkKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCByZXQpOwo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgZ290byBlcnJfbTJtX2N0eF9pbml0Owo+ PiDCoMKgwqDCoMKgIH0KPj4gK8KgwqDCoCBzcmNfdnEgPSB2NGwyX20ybV9nZXRfdnEoY3R4LT5t Mm1fY3R4LAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIFY0TDJfQlVGX1RZUEVf VklERU9fT1VUUFVUX01QTEFORSk7Cj4+ICvCoMKgwqAgY3R4LT5lbXB0eV9mbHVzaF9idWYudmIu dmIyX2J1Zi52YjJfcXVldWUgPSBzcmNfdnE7Cj4+IMKgwqDCoMKgwqAgbXRrX3Zjb2RlY19lbmNf c2V0X2RlZmF1bHRfcGFyYW1zKGN0eCk7Cj4+IMKgwqDCoMKgwqAgaWYgKHY0bDJfZmhfaXNfc2lu Z3VsYXIoJmN0eC0+ZmgpKSB7Cj4+CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpMaW51eC1tZWRpYXRlayBtYWlsaW5nIGxpc3QKTGludXgtbWVkaWF0ZWtA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LW1lZGlhdGVrCg==