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=-10.2 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, UNWANTED_LANGUAGE_BODY,URIBL_BLOCKED,USER_AGENT_GIT 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 EF2BDC433E1 for ; Fri, 14 Aug 2020 07:25:16 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (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 AA628206DA for ; Fri, 14 Aug 2020 07:25:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="DGNxJmlX"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="bkF2UT4Z" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AA628206DA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.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=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=1aFgXPmMcfTtBolt7jbWR2P0MWFf0yDFmO/jbVJs7QM=; b=DGNxJmlXMIXJ7IE78z5Yzvp32 enL1bGIn0CDiX6BTBAh6ai2Y4Uh/G1Fo59Zn4tDF8MxJr97emzkXbJLCIW66YfiALv0EhkqjtkYg5 xBDfY4jI4OI94sxYHr6rJC2r6/FOlC/qORHt4/Jp3szo8jPsynRg4hidu1d2huJf3KLwDBLPixhb3 lbQVLx0xa3I8CPaxbRU44QmM5foH1N0xZJlemSgICHHWWrTtPvkUkta3eb5Pw/3TzvmXjmQZRkpxf 4ml4StF8QV9vAulw2hgKrZAa3OpihYvg1ZCEHy8cpPNdT7iSiwC/B4Ra6uv2KL0N5q/QUgYP11Y82 Gsh5bkR1A==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1k6U5G-0004HJ-NA; Fri, 14 Aug 2020 07:25:02 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1k6U3f-0003N6-Q4; Fri, 14 Aug 2020 07:23:26 +0000 X-UUID: fc06895743834811b10f637610fc1425-20200813 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=KoruD4ltcBpo2ra3J9S0eAKfJ8GHH4yZd7zq0+/1eIE=; b=bkF2UT4Z8KpZPXt/NuA3Diy/8786zdN7bRdkkVn6e/34BxVifTTMn3S0jEyml9CrVRn5+IOTi0g2AHIvUA9ijdJ8o247WQ6sT5x+W0jcO4YTMGl+AbnnbiNnEUy3avUmUiRQ5v9XS6QtvSikZhKQasP9tyOzFtLVF/3UvLukkXo=; X-UUID: fc06895743834811b10f637610fc1425-20200813 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 18430178; Thu, 13 Aug 2020 23:23:11 -0800 Received: from mtkmbs07n1.mediatek.inc (172.21.101.16) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 14 Aug 2020 00:13:42 -0700 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 14 Aug 2020 15:13:37 +0800 Received: from localhost.localdomain (10.17.3.153) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Fri, 14 Aug 2020 15:13:36 +0800 From: Xia Jiang To: Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , "Matthias Brugger" , Rick Chang Subject: [PATCH v12 28/29] media: platform: Using the variant structure to contain the varability between dec and enc Date: Fri, 14 Aug 2020 15:12:01 +0800 Message-ID: <20200814071202.25067-30-xia.jiang@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20200814071202.25067-1-xia.jiang@mediatek.com> References: <20200814071202.25067-1-xia.jiang@mediatek.com> MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200814_032324_069431_E41B0826 X-CRM114-Status: GOOD ( 17.50 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: maoguang.meng@mediatek.com, devicetree@vger.kernel.org, mojahsu@chromium.org, srv_heupstream@mediatek.com, linux-kernel@vger.kernel.org, Tomasz Figa , senozhatsky@chromium.org, drinkcat@chromium.org, linux-mediatek@lists.infradead.org, Xia Jiang , linux-media@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Marek Szyprowski Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org Add varability which would be used between jpeg dec and enc to a match data structure, it will make the code linear. Reviewed-by: Tomasz Figa Signed-off-by: Xia Jiang --- v12: no changes --- .../media/platform/mtk-jpeg/mtk_jpeg_core.c | 113 +++++++++++------- .../media/platform/mtk-jpeg/mtk_jpeg_core.h | 36 +++++- 2 files changed, 104 insertions(+), 45 deletions(-) diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c index 3d1383d2eac4..3d95c7f0a22d 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c @@ -80,8 +80,8 @@ static int mtk_jpeg_querycap(struct file *file, void *priv, { struct mtk_jpeg_dev *jpeg = video_drvdata(file); - strscpy(cap->driver, MTK_JPEG_NAME " decoder", sizeof(cap->driver)); - strscpy(cap->card, MTK_JPEG_NAME " decoder", sizeof(cap->card)); + strscpy(cap->driver, jpeg->variant->dev_name, sizeof(cap->driver)); + strscpy(cap->card, jpeg->variant->dev_name, sizeof(cap->card)); snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", dev_name(jpeg->dev)); @@ -112,15 +112,23 @@ static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, static int mtk_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f) { - return mtk_jpeg_enum_fmt(mtk_jpeg_dec_formats, MTK_JPEG_DEC_NUM_FORMATS, - f, MTK_JPEG_FMT_FLAG_CAPTURE); + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + return mtk_jpeg_enum_fmt(jpeg->variant->formats, + jpeg->variant->num_formats, f, + MTK_JPEG_FMT_FLAG_CAPTURE); } static int mtk_jpeg_enum_fmt_vid_out(struct file *file, void *priv, struct v4l2_fmtdesc *f) { - return mtk_jpeg_enum_fmt(mtk_jpeg_dec_formats, MTK_JPEG_DEC_NUM_FORMATS, - f, MTK_JPEG_FMT_FLAG_OUTPUT); + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + return mtk_jpeg_enum_fmt(jpeg->variant->formats, + jpeg->variant->num_formats, f, + MTK_JPEG_FMT_FLAG_OUTPUT); } static struct mtk_jpeg_q_data *mtk_jpeg_get_q_data(struct mtk_jpeg_ctx *ctx, @@ -244,10 +252,11 @@ static int mtk_jpeg_try_fmt_vid_cap_mplane(struct file *file, void *priv, struct v4l2_format *f) { struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; struct mtk_jpeg_fmt *fmt; - fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, f->fmt.pix_mp.pixelformat, MTK_JPEG_FMT_FLAG_CAPTURE); if (!fmt) @@ -272,10 +281,11 @@ static int mtk_jpeg_try_fmt_vid_out_mplane(struct file *file, void *priv, struct v4l2_format *f) { struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; struct mtk_jpeg_fmt *fmt; - fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, f->fmt.pix_mp.pixelformat, MTK_JPEG_FMT_FLAG_OUTPUT); if (!fmt) @@ -316,9 +326,8 @@ static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, return -EBUSY; } - - q_data->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, pix_mp->pixelformat, fmt_type); q_data->pix_mp.width = pix_mp->width; q_data->pix_mp.height = pix_mp->height; @@ -519,9 +528,10 @@ static bool mtk_jpeg_check_resolution_change(struct mtk_jpeg_ctx *ctx, } q_data = &ctx->cap_q; - if (q_data->fmt != mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, param->dst_fourcc, - MTK_JPEG_FMT_FLAG_CAPTURE)) { + if (q_data->fmt != + mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, param->dst_fourcc, + MTK_JPEG_FMT_FLAG_CAPTURE)) { v4l2_dbg(1, debug, &jpeg->v4l2_dev, "format change\n"); return true; } @@ -542,8 +552,8 @@ static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, q_data = &ctx->cap_q; q_data->pix_mp.width = param->dec_w; q_data->pix_mp.height = param->dec_h; - q_data->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, param->dst_fourcc, MTK_JPEG_FMT_FLAG_CAPTURE); @@ -749,13 +759,14 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq) { struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; int ret; src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; src_vq->io_modes = VB2_DMABUF | VB2_MMAP; src_vq->drv_priv = ctx; src_vq->buf_struct_size = sizeof(struct mtk_jpeg_src_buf); - src_vq->ops = &mtk_jpeg_dec_qops; + src_vq->ops = jpeg->variant->qops; src_vq->mem_ops = &vb2_dma_contig_memops; src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; src_vq->lock = &ctx->jpeg->lock; @@ -768,7 +779,7 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; dst_vq->drv_priv = ctx; dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); - dst_vq->ops = &mtk_jpeg_dec_qops; + dst_vq->ops = jpeg->variant->qops; dst_vq->mem_ops = &vb2_dma_contig_memops; dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; dst_vq->lock = &ctx->jpeg->lock; @@ -786,14 +797,16 @@ static void mtk_jpeg_clk_on(struct mtk_jpeg_dev *jpeg) if (ret) dev_err(jpeg->dev, "mtk_smi_larb_get larbvdec fail %d\n", ret); - ret = clk_bulk_prepare_enable(jpeg->num_clks, jpeg->clks); + ret = clk_bulk_prepare_enable(jpeg->variant->num_clks, + jpeg->variant->clks); if (ret) dev_err(jpeg->dev, "Failed to open jpeg clk: %d\n", ret); } static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) { - clk_bulk_disable_unprepare(jpeg->num_clks, jpeg->clks); + clk_bulk_disable_unprepare(jpeg->variant->num_clks, + jpeg->variant->clks); mtk_smi_larb_put(jpeg->larb); } @@ -847,24 +860,25 @@ static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) { struct mtk_jpeg_q_data *q = &ctx->out_q; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; q->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; - q->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, - V4L2_PIX_FMT_JPEG, + q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + jpeg->variant->out_q_default_fourcc, MTK_JPEG_FMT_FLAG_OUTPUT); q->pix_mp.width = MTK_JPEG_MIN_WIDTH; q->pix_mp.height = MTK_JPEG_MIN_HEIGHT; mtk_jpeg_try_fmt_mplane(&q->pix_mp, q->fmt); q = &ctx->cap_q; - q->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, - V4L2_PIX_FMT_YUV420M, + q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + jpeg->variant->cap_q_default_fourcc, MTK_JPEG_FMT_FLAG_CAPTURE); q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; @@ -963,9 +977,8 @@ static int mtk_jpeg_clk_init(struct mtk_jpeg_dev *jpeg) jpeg->larb = &pdev->dev; - jpeg->clks = mt8173_jpeg_dec_clocks; - jpeg->num_clks = ARRAY_SIZE(mt8173_jpeg_dec_clocks); - ret = devm_clk_bulk_get(jpeg->dev, jpeg->num_clks, jpeg->clks); + ret = devm_clk_bulk_get(jpeg->dev, jpeg->variant->num_clks, + jpeg->variant->clks); if (ret) { dev_err(&pdev->dev, "failed to get jpeg clock:%d\n", ret); return ret; @@ -985,7 +998,7 @@ static void mtk_jpeg_job_timeout_work(struct work_struct *work) src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - mtk_jpeg_dec_reset(jpeg->reg_base); + jpeg->variant->hw_reset(jpeg->reg_base); pm_runtime_put(jpeg->dev); @@ -1007,6 +1020,7 @@ static int mtk_jpeg_probe(struct platform_device *pdev) mutex_init(&jpeg->lock); spin_lock_init(&jpeg->hw_lock); jpeg->dev = &pdev->dev; + jpeg->variant = of_device_get_match_data(jpeg->dev); INIT_DELAYED_WORK(&jpeg->job_timeout_work, mtk_jpeg_job_timeout_work); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); @@ -1022,8 +1036,8 @@ static int mtk_jpeg_probe(struct platform_device *pdev) return jpeg_irq; } - ret = devm_request_irq(&pdev->dev, jpeg_irq, mtk_jpeg_dec_irq, 0, - pdev->name, jpeg); + ret = devm_request_irq(&pdev->dev, jpeg_irq, + jpeg->variant->irq_handler, 0, pdev->name, jpeg); if (ret) { dev_err(&pdev->dev, "Failed to request jpeg_irq %d (%d)\n", jpeg_irq, ret); @@ -1043,7 +1057,8 @@ static int mtk_jpeg_probe(struct platform_device *pdev) goto err_dev_register; } - jpeg->m2m_dev = v4l2_m2m_init(&mtk_jpeg_dec_m2m_ops); + jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops); + if (IS_ERR(jpeg->m2m_dev)) { v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n"); ret = PTR_ERR(jpeg->m2m_dev); @@ -1056,9 +1071,9 @@ static int mtk_jpeg_probe(struct platform_device *pdev) goto err_vfd_jpeg_alloc; } snprintf(jpeg->vdev->name, sizeof(jpeg->vdev->name), - "%s-dec", MTK_JPEG_NAME); + "%s", jpeg->variant->dev_name); jpeg->vdev->fops = &mtk_jpeg_fops; - jpeg->vdev->ioctl_ops = &mtk_jpeg_dec_ioctl_ops; + jpeg->vdev->ioctl_ops = jpeg->variant->ioctl_ops; jpeg->vdev->minor = -1; jpeg->vdev->release = video_device_release; jpeg->vdev->lock = &jpeg->lock; @@ -1075,8 +1090,9 @@ static int mtk_jpeg_probe(struct platform_device *pdev) video_set_drvdata(jpeg->vdev, jpeg); v4l2_info(&jpeg->v4l2_dev, - "decoder device registered as /dev/video%d (%d,%d)\n", - jpeg->vdev->num, VIDEO_MAJOR, jpeg->vdev->minor); + "%s device registered as /dev/video%d (%d,%d)\n", + jpeg->variant->dev_name, jpeg->vdev->num, + VIDEO_MAJOR, jpeg->vdev->minor); platform_set_drvdata(pdev, jpeg); @@ -1159,14 +1175,29 @@ static const struct dev_pm_ops mtk_jpeg_pm_ops = { SET_RUNTIME_PM_OPS(mtk_jpeg_pm_suspend, mtk_jpeg_pm_resume, NULL) }; +static const struct mtk_jpeg_variant mt8173_jpeg_drvdata = { + .clks = mt8173_jpeg_dec_clocks, + .num_clks = ARRAY_SIZE(mt8173_jpeg_dec_clocks), + .formats = mtk_jpeg_dec_formats, + .num_formats = MTK_JPEG_DEC_NUM_FORMATS, + .qops = &mtk_jpeg_dec_qops, + .irq_handler = mtk_jpeg_dec_irq, + .hw_reset = mtk_jpeg_dec_reset, + .m2m_ops = &mtk_jpeg_dec_m2m_ops, + .dev_name = "mtk-jpeg-dec", + .ioctl_ops = &mtk_jpeg_dec_ioctl_ops, + .out_q_default_fourcc = V4L2_PIX_FMT_JPEG, + .cap_q_default_fourcc = V4L2_PIX_FMT_YUV420M, +}; + static const struct of_device_id mtk_jpeg_match[] = { { .compatible = "mediatek,mt8173-jpgdec", - .data = NULL, + .data = &mt8173_jpeg_drvdata, }, { .compatible = "mediatek,mt2701-jpgdec", - .data = NULL, + .data = &mt8173_jpeg_drvdata, }, {}, }; diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h index 0f27480dd90d..d11d366a247e 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h @@ -41,6 +41,36 @@ enum mtk_jpeg_ctx_state { MTK_JPEG_SOURCE_CHANGE, }; +/** + * mtk_jpeg_variant - mtk jpeg driver variant + * @clks: clock names + * @num_clks: numbers of clock + * @format: jpeg driver's internal color format + * @num_format: number of format + * @qops: the callback of jpeg vb2_ops + * @irq_handler: jpeg irq handler callback + * @hw_reset: jpeg hardware reset callback + * @m2m_ops: the callback of jpeg v4l2_m2m_ops + * @dev_name: jpeg device name + * @ioctl_ops: the callback of jpeg v4l2_ioctl_ops + * @out_q_default_fourcc: output queue default fourcc + * @cap_q_default_fourcc: capture queue default fourcc + */ +struct mtk_jpeg_variant { + struct clk_bulk_data *clks; + int num_clks; + struct mtk_jpeg_fmt *formats; + int num_formats; + const struct vb2_ops *qops; + irqreturn_t (*irq_handler)(int irq, void *priv); + void (*hw_reset)(void __iomem *base); + const struct v4l2_m2m_ops *m2m_ops; + const char *dev_name; + const struct v4l2_ioctl_ops *ioctl_ops; + u32 out_q_default_fourcc; + u32 cap_q_default_fourcc; +}; + /** * struct mt_jpeg - JPEG IP abstraction * @lock: the mutex protecting this structure @@ -52,10 +82,9 @@ enum mtk_jpeg_ctx_state { * @alloc_ctx: videobuf2 memory allocator's context * @vdev: video device node for jpeg mem2mem mode * @reg_base: JPEG registers mapping - * @clks: clock names - * @num_clks: numbers of clock * @larb: SMI device * @job_timeout_work: IRQ timeout structure + * @variant: driver variant to be used */ struct mtk_jpeg_dev { struct mutex lock; @@ -67,10 +96,9 @@ struct mtk_jpeg_dev { void *alloc_ctx; struct video_device *vdev; void __iomem *reg_base; - struct clk_bulk_data *clks; - int num_clks; struct device *larb; struct delayed_work job_timeout_work; + const struct mtk_jpeg_variant *variant; }; /** -- 2.18.0 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek 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=-10.2 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, UNWANTED_LANGUAGE_BODY,URIBL_BLOCKED,USER_AGENT_GIT 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 57B78C433DF for ; Fri, 14 Aug 2020 07:27:14 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (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 A83C220708 for ; Fri, 14 Aug 2020 07:27:13 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Sv2EUnn9"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="bkF2UT4Z" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A83C220708 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=XdOWyLR1h/WnRSOfRybhrlUyg6okYVs047x0EYxvnsA=; b=Sv2EUnn96gGLQqduJ6TttG2iC LJBfT1TORBx6A2UCPTF0xcruIW/2SJG0jska3eXcNihg1qtuekmKa6P1ssEp5LdqMuZ7ZSzoqs+Wr +pEckaF7zf0DuDMsJ9VUZO9fltt/Dyq8z2UQlJ0TQiJxJnrWIzDT3d5n3ZMRJ44JlaJhx6J806QJp Q/L9sFAKUhFQ8cIsj1JxjQPskJ4JHYf771y8DQiG0iY6d/hIWn/as426psVd+kSKLrmk+zXP7y3gm uQmnNGMqzQuvURAVr5G6GETS9NsIhlYIprD6lscV0D7p/CiKVmgjYpbhHJJ7eYyy6rmSZzXlTMSw2 r4uEcH7jA==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1k6U5U-0004RM-Ts; Fri, 14 Aug 2020 07:25:16 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1k6U3f-0003N6-Q4; Fri, 14 Aug 2020 07:23:26 +0000 X-UUID: fc06895743834811b10f637610fc1425-20200813 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=KoruD4ltcBpo2ra3J9S0eAKfJ8GHH4yZd7zq0+/1eIE=; b=bkF2UT4Z8KpZPXt/NuA3Diy/8786zdN7bRdkkVn6e/34BxVifTTMn3S0jEyml9CrVRn5+IOTi0g2AHIvUA9ijdJ8o247WQ6sT5x+W0jcO4YTMGl+AbnnbiNnEUy3avUmUiRQ5v9XS6QtvSikZhKQasP9tyOzFtLVF/3UvLukkXo=; X-UUID: fc06895743834811b10f637610fc1425-20200813 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 18430178; Thu, 13 Aug 2020 23:23:11 -0800 Received: from mtkmbs07n1.mediatek.inc (172.21.101.16) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 14 Aug 2020 00:13:42 -0700 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 14 Aug 2020 15:13:37 +0800 Received: from localhost.localdomain (10.17.3.153) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Fri, 14 Aug 2020 15:13:36 +0800 From: Xia Jiang To: Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , "Matthias Brugger" , Rick Chang Subject: [PATCH v12 28/29] media: platform: Using the variant structure to contain the varability between dec and enc Date: Fri, 14 Aug 2020 15:12:01 +0800 Message-ID: <20200814071202.25067-30-xia.jiang@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20200814071202.25067-1-xia.jiang@mediatek.com> References: <20200814071202.25067-1-xia.jiang@mediatek.com> MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200814_032324_069431_E41B0826 X-CRM114-Status: GOOD ( 17.50 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: maoguang.meng@mediatek.com, devicetree@vger.kernel.org, mojahsu@chromium.org, srv_heupstream@mediatek.com, linux-kernel@vger.kernel.org, Tomasz Figa , senozhatsky@chromium.org, drinkcat@chromium.org, linux-mediatek@lists.infradead.org, Xia Jiang , linux-media@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Marek Szyprowski Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Add varability which would be used between jpeg dec and enc to a match data structure, it will make the code linear. Reviewed-by: Tomasz Figa Signed-off-by: Xia Jiang --- v12: no changes --- .../media/platform/mtk-jpeg/mtk_jpeg_core.c | 113 +++++++++++------- .../media/platform/mtk-jpeg/mtk_jpeg_core.h | 36 +++++- 2 files changed, 104 insertions(+), 45 deletions(-) diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c index 3d1383d2eac4..3d95c7f0a22d 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c @@ -80,8 +80,8 @@ static int mtk_jpeg_querycap(struct file *file, void *priv, { struct mtk_jpeg_dev *jpeg = video_drvdata(file); - strscpy(cap->driver, MTK_JPEG_NAME " decoder", sizeof(cap->driver)); - strscpy(cap->card, MTK_JPEG_NAME " decoder", sizeof(cap->card)); + strscpy(cap->driver, jpeg->variant->dev_name, sizeof(cap->driver)); + strscpy(cap->card, jpeg->variant->dev_name, sizeof(cap->card)); snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", dev_name(jpeg->dev)); @@ -112,15 +112,23 @@ static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, static int mtk_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f) { - return mtk_jpeg_enum_fmt(mtk_jpeg_dec_formats, MTK_JPEG_DEC_NUM_FORMATS, - f, MTK_JPEG_FMT_FLAG_CAPTURE); + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + return mtk_jpeg_enum_fmt(jpeg->variant->formats, + jpeg->variant->num_formats, f, + MTK_JPEG_FMT_FLAG_CAPTURE); } static int mtk_jpeg_enum_fmt_vid_out(struct file *file, void *priv, struct v4l2_fmtdesc *f) { - return mtk_jpeg_enum_fmt(mtk_jpeg_dec_formats, MTK_JPEG_DEC_NUM_FORMATS, - f, MTK_JPEG_FMT_FLAG_OUTPUT); + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + return mtk_jpeg_enum_fmt(jpeg->variant->formats, + jpeg->variant->num_formats, f, + MTK_JPEG_FMT_FLAG_OUTPUT); } static struct mtk_jpeg_q_data *mtk_jpeg_get_q_data(struct mtk_jpeg_ctx *ctx, @@ -244,10 +252,11 @@ static int mtk_jpeg_try_fmt_vid_cap_mplane(struct file *file, void *priv, struct v4l2_format *f) { struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; struct mtk_jpeg_fmt *fmt; - fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, f->fmt.pix_mp.pixelformat, MTK_JPEG_FMT_FLAG_CAPTURE); if (!fmt) @@ -272,10 +281,11 @@ static int mtk_jpeg_try_fmt_vid_out_mplane(struct file *file, void *priv, struct v4l2_format *f) { struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; struct mtk_jpeg_fmt *fmt; - fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, f->fmt.pix_mp.pixelformat, MTK_JPEG_FMT_FLAG_OUTPUT); if (!fmt) @@ -316,9 +326,8 @@ static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, return -EBUSY; } - - q_data->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, pix_mp->pixelformat, fmt_type); q_data->pix_mp.width = pix_mp->width; q_data->pix_mp.height = pix_mp->height; @@ -519,9 +528,10 @@ static bool mtk_jpeg_check_resolution_change(struct mtk_jpeg_ctx *ctx, } q_data = &ctx->cap_q; - if (q_data->fmt != mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, param->dst_fourcc, - MTK_JPEG_FMT_FLAG_CAPTURE)) { + if (q_data->fmt != + mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, param->dst_fourcc, + MTK_JPEG_FMT_FLAG_CAPTURE)) { v4l2_dbg(1, debug, &jpeg->v4l2_dev, "format change\n"); return true; } @@ -542,8 +552,8 @@ static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, q_data = &ctx->cap_q; q_data->pix_mp.width = param->dec_w; q_data->pix_mp.height = param->dec_h; - q_data->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, + q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, param->dst_fourcc, MTK_JPEG_FMT_FLAG_CAPTURE); @@ -749,13 +759,14 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq) { struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; int ret; src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; src_vq->io_modes = VB2_DMABUF | VB2_MMAP; src_vq->drv_priv = ctx; src_vq->buf_struct_size = sizeof(struct mtk_jpeg_src_buf); - src_vq->ops = &mtk_jpeg_dec_qops; + src_vq->ops = jpeg->variant->qops; src_vq->mem_ops = &vb2_dma_contig_memops; src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; src_vq->lock = &ctx->jpeg->lock; @@ -768,7 +779,7 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; dst_vq->drv_priv = ctx; dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); - dst_vq->ops = &mtk_jpeg_dec_qops; + dst_vq->ops = jpeg->variant->qops; dst_vq->mem_ops = &vb2_dma_contig_memops; dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; dst_vq->lock = &ctx->jpeg->lock; @@ -786,14 +797,16 @@ static void mtk_jpeg_clk_on(struct mtk_jpeg_dev *jpeg) if (ret) dev_err(jpeg->dev, "mtk_smi_larb_get larbvdec fail %d\n", ret); - ret = clk_bulk_prepare_enable(jpeg->num_clks, jpeg->clks); + ret = clk_bulk_prepare_enable(jpeg->variant->num_clks, + jpeg->variant->clks); if (ret) dev_err(jpeg->dev, "Failed to open jpeg clk: %d\n", ret); } static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) { - clk_bulk_disable_unprepare(jpeg->num_clks, jpeg->clks); + clk_bulk_disable_unprepare(jpeg->variant->num_clks, + jpeg->variant->clks); mtk_smi_larb_put(jpeg->larb); } @@ -847,24 +860,25 @@ static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) { struct mtk_jpeg_q_data *q = &ctx->out_q; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; q->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; - q->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, - V4L2_PIX_FMT_JPEG, + q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + jpeg->variant->out_q_default_fourcc, MTK_JPEG_FMT_FLAG_OUTPUT); q->pix_mp.width = MTK_JPEG_MIN_WIDTH; q->pix_mp.height = MTK_JPEG_MIN_HEIGHT; mtk_jpeg_try_fmt_mplane(&q->pix_mp, q->fmt); q = &ctx->cap_q; - q->fmt = mtk_jpeg_find_format(mtk_jpeg_dec_formats, - MTK_JPEG_DEC_NUM_FORMATS, - V4L2_PIX_FMT_YUV420M, + q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + jpeg->variant->cap_q_default_fourcc, MTK_JPEG_FMT_FLAG_CAPTURE); q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; @@ -963,9 +977,8 @@ static int mtk_jpeg_clk_init(struct mtk_jpeg_dev *jpeg) jpeg->larb = &pdev->dev; - jpeg->clks = mt8173_jpeg_dec_clocks; - jpeg->num_clks = ARRAY_SIZE(mt8173_jpeg_dec_clocks); - ret = devm_clk_bulk_get(jpeg->dev, jpeg->num_clks, jpeg->clks); + ret = devm_clk_bulk_get(jpeg->dev, jpeg->variant->num_clks, + jpeg->variant->clks); if (ret) { dev_err(&pdev->dev, "failed to get jpeg clock:%d\n", ret); return ret; @@ -985,7 +998,7 @@ static void mtk_jpeg_job_timeout_work(struct work_struct *work) src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - mtk_jpeg_dec_reset(jpeg->reg_base); + jpeg->variant->hw_reset(jpeg->reg_base); pm_runtime_put(jpeg->dev); @@ -1007,6 +1020,7 @@ static int mtk_jpeg_probe(struct platform_device *pdev) mutex_init(&jpeg->lock); spin_lock_init(&jpeg->hw_lock); jpeg->dev = &pdev->dev; + jpeg->variant = of_device_get_match_data(jpeg->dev); INIT_DELAYED_WORK(&jpeg->job_timeout_work, mtk_jpeg_job_timeout_work); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); @@ -1022,8 +1036,8 @@ static int mtk_jpeg_probe(struct platform_device *pdev) return jpeg_irq; } - ret = devm_request_irq(&pdev->dev, jpeg_irq, mtk_jpeg_dec_irq, 0, - pdev->name, jpeg); + ret = devm_request_irq(&pdev->dev, jpeg_irq, + jpeg->variant->irq_handler, 0, pdev->name, jpeg); if (ret) { dev_err(&pdev->dev, "Failed to request jpeg_irq %d (%d)\n", jpeg_irq, ret); @@ -1043,7 +1057,8 @@ static int mtk_jpeg_probe(struct platform_device *pdev) goto err_dev_register; } - jpeg->m2m_dev = v4l2_m2m_init(&mtk_jpeg_dec_m2m_ops); + jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops); + if (IS_ERR(jpeg->m2m_dev)) { v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n"); ret = PTR_ERR(jpeg->m2m_dev); @@ -1056,9 +1071,9 @@ static int mtk_jpeg_probe(struct platform_device *pdev) goto err_vfd_jpeg_alloc; } snprintf(jpeg->vdev->name, sizeof(jpeg->vdev->name), - "%s-dec", MTK_JPEG_NAME); + "%s", jpeg->variant->dev_name); jpeg->vdev->fops = &mtk_jpeg_fops; - jpeg->vdev->ioctl_ops = &mtk_jpeg_dec_ioctl_ops; + jpeg->vdev->ioctl_ops = jpeg->variant->ioctl_ops; jpeg->vdev->minor = -1; jpeg->vdev->release = video_device_release; jpeg->vdev->lock = &jpeg->lock; @@ -1075,8 +1090,9 @@ static int mtk_jpeg_probe(struct platform_device *pdev) video_set_drvdata(jpeg->vdev, jpeg); v4l2_info(&jpeg->v4l2_dev, - "decoder device registered as /dev/video%d (%d,%d)\n", - jpeg->vdev->num, VIDEO_MAJOR, jpeg->vdev->minor); + "%s device registered as /dev/video%d (%d,%d)\n", + jpeg->variant->dev_name, jpeg->vdev->num, + VIDEO_MAJOR, jpeg->vdev->minor); platform_set_drvdata(pdev, jpeg); @@ -1159,14 +1175,29 @@ static const struct dev_pm_ops mtk_jpeg_pm_ops = { SET_RUNTIME_PM_OPS(mtk_jpeg_pm_suspend, mtk_jpeg_pm_resume, NULL) }; +static const struct mtk_jpeg_variant mt8173_jpeg_drvdata = { + .clks = mt8173_jpeg_dec_clocks, + .num_clks = ARRAY_SIZE(mt8173_jpeg_dec_clocks), + .formats = mtk_jpeg_dec_formats, + .num_formats = MTK_JPEG_DEC_NUM_FORMATS, + .qops = &mtk_jpeg_dec_qops, + .irq_handler = mtk_jpeg_dec_irq, + .hw_reset = mtk_jpeg_dec_reset, + .m2m_ops = &mtk_jpeg_dec_m2m_ops, + .dev_name = "mtk-jpeg-dec", + .ioctl_ops = &mtk_jpeg_dec_ioctl_ops, + .out_q_default_fourcc = V4L2_PIX_FMT_JPEG, + .cap_q_default_fourcc = V4L2_PIX_FMT_YUV420M, +}; + static const struct of_device_id mtk_jpeg_match[] = { { .compatible = "mediatek,mt8173-jpgdec", - .data = NULL, + .data = &mt8173_jpeg_drvdata, }, { .compatible = "mediatek,mt2701-jpgdec", - .data = NULL, + .data = &mt8173_jpeg_drvdata, }, {}, }; diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h index 0f27480dd90d..d11d366a247e 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h @@ -41,6 +41,36 @@ enum mtk_jpeg_ctx_state { MTK_JPEG_SOURCE_CHANGE, }; +/** + * mtk_jpeg_variant - mtk jpeg driver variant + * @clks: clock names + * @num_clks: numbers of clock + * @format: jpeg driver's internal color format + * @num_format: number of format + * @qops: the callback of jpeg vb2_ops + * @irq_handler: jpeg irq handler callback + * @hw_reset: jpeg hardware reset callback + * @m2m_ops: the callback of jpeg v4l2_m2m_ops + * @dev_name: jpeg device name + * @ioctl_ops: the callback of jpeg v4l2_ioctl_ops + * @out_q_default_fourcc: output queue default fourcc + * @cap_q_default_fourcc: capture queue default fourcc + */ +struct mtk_jpeg_variant { + struct clk_bulk_data *clks; + int num_clks; + struct mtk_jpeg_fmt *formats; + int num_formats; + const struct vb2_ops *qops; + irqreturn_t (*irq_handler)(int irq, void *priv); + void (*hw_reset)(void __iomem *base); + const struct v4l2_m2m_ops *m2m_ops; + const char *dev_name; + const struct v4l2_ioctl_ops *ioctl_ops; + u32 out_q_default_fourcc; + u32 cap_q_default_fourcc; +}; + /** * struct mt_jpeg - JPEG IP abstraction * @lock: the mutex protecting this structure @@ -52,10 +82,9 @@ enum mtk_jpeg_ctx_state { * @alloc_ctx: videobuf2 memory allocator's context * @vdev: video device node for jpeg mem2mem mode * @reg_base: JPEG registers mapping - * @clks: clock names - * @num_clks: numbers of clock * @larb: SMI device * @job_timeout_work: IRQ timeout structure + * @variant: driver variant to be used */ struct mtk_jpeg_dev { struct mutex lock; @@ -67,10 +96,9 @@ struct mtk_jpeg_dev { void *alloc_ctx; struct video_device *vdev; void __iomem *reg_base; - struct clk_bulk_data *clks; - int num_clks; struct device *larb; struct delayed_work job_timeout_work; + const struct mtk_jpeg_variant *variant; }; /** -- 2.18.0 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel 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=-8.6 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MIME_BASE64_TEXT,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNPARSEABLE_RELAY,UNWANTED_LANGUAGE_BODY,URIBL_BLOCKED,USER_AGENT_GIT 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 1F922C433E5 for ; Fri, 14 Aug 2020 07:14:12 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E373220866 for ; Fri, 14 Aug 2020 07:14:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="PmB1koxv" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726989AbgHNHNs (ORCPT ); Fri, 14 Aug 2020 03:13:48 -0400 Received: from mailgw01.mediatek.com ([210.61.82.183]:17558 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726952AbgHNHNr (ORCPT ); Fri, 14 Aug 2020 03:13:47 -0400 X-UUID: 283e4c499420498b9e28b2f7e60f64d3-20200814 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=KoruD4ltcBpo2ra3J9S0eAKfJ8GHH4yZd7zq0+/1eIE=; b=PmB1koxvh6OTuypsOr9C/Cbo692uN29GNmnTLlSLBoOJMybtPaCn0an9KQuMZ8huwU0E4rVP06UgFiGWOj3axAZNmjaPmPq52qTiOnyniFNKFciKPNJeWWJnfPUbzEO7v3WkMVWGBA+e7dIM51Wyo4Vz+Yvi11wG8utyISPvows=; X-UUID: 283e4c499420498b9e28b2f7e60f64d3-20200814 Received: from mtkcas10.mediatek.inc [(172.21.101.39)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 567980442; Fri, 14 Aug 2020 15:13:40 +0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 14 Aug 2020 15:13:37 +0800 Received: from localhost.localdomain (10.17.3.153) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Fri, 14 Aug 2020 15:13:36 +0800 From: Xia Jiang To: Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , Matthias Brugger , Rick Chang CC: , , , , , Marek Szyprowski , Tomasz Figa , , , , , , Xia Jiang Subject: [PATCH v12 28/29] media: platform: Using the variant structure to contain the varability between dec and enc Date: Fri, 14 Aug 2020 15:12:01 +0800 Message-ID: <20200814071202.25067-30-xia.jiang@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20200814071202.25067-1-xia.jiang@mediatek.com> References: <20200814071202.25067-1-xia.jiang@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-MTK: N Content-Transfer-Encoding: base64 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org QWRkIHZhcmFiaWxpdHkgd2hpY2ggd291bGQgYmUgdXNlZCBiZXR3ZWVuIGpwZWcgZGVjIGFuZCBl bmMgdG8gYSBtYXRjaA0KZGF0YSBzdHJ1Y3R1cmUsIGl0IHdpbGwgbWFrZSB0aGUgY29kZSBsaW5l YXIuDQoNClJldmlld2VkLWJ5OiBUb21hc3ogRmlnYSA8dGZpZ2FAY2hyb21pdW0ub3JnPg0KU2ln bmVkLW9mZi1ieTogWGlhIEppYW5nIDx4aWEuamlhbmdAbWVkaWF0ZWsuY29tPg0KLS0tDQp2MTI6 IG5vIGNoYW5nZXMNCi0tLQ0KIC4uLi9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19j b3JlLmMgICB8IDExMyArKysrKysrKysrKy0tLS0tLS0NCiAuLi4vbWVkaWEvcGxhdGZvcm0vbXRr LWpwZWcvbXRrX2pwZWdfY29yZS5oICAgfCAgMzYgKysrKystDQogMiBmaWxlcyBjaGFuZ2VkLCAx MDQgaW5zZXJ0aW9ucygrKSwgNDUgZGVsZXRpb25zKC0pDQoNCmRpZmYgLS1naXQgYS9kcml2ZXJz L21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2NvcmUuYyBiL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5jDQppbmRleCAzZDEzODNkMmVhYzQuLjNk OTVjN2YwYTIyZCAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcv bXRrX2pwZWdfY29yZS5jDQorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210 a19qcGVnX2NvcmUuYw0KQEAgLTgwLDggKzgwLDggQEAgc3RhdGljIGludCBtdGtfanBlZ19xdWVy eWNhcChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCiB7DQogCXN0cnVjdCBtdGtfanBl Z19kZXYgKmpwZWcgPSB2aWRlb19kcnZkYXRhKGZpbGUpOw0KIA0KLQlzdHJzY3B5KGNhcC0+ZHJp dmVyLCBNVEtfSlBFR19OQU1FICIgZGVjb2RlciIsIHNpemVvZihjYXAtPmRyaXZlcikpOw0KLQlz dHJzY3B5KGNhcC0+Y2FyZCwgTVRLX0pQRUdfTkFNRSAiIGRlY29kZXIiLCBzaXplb2YoY2FwLT5j YXJkKSk7DQorCXN0cnNjcHkoY2FwLT5kcml2ZXIsIGpwZWctPnZhcmlhbnQtPmRldl9uYW1lLCBz aXplb2YoY2FwLT5kcml2ZXIpKTsNCisJc3Ryc2NweShjYXAtPmNhcmQsIGpwZWctPnZhcmlhbnQt PmRldl9uYW1lLCBzaXplb2YoY2FwLT5jYXJkKSk7DQogCXNucHJpbnRmKGNhcC0+YnVzX2luZm8s IHNpemVvZihjYXAtPmJ1c19pbmZvKSwgInBsYXRmb3JtOiVzIiwNCiAJCSBkZXZfbmFtZShqcGVn LT5kZXYpKTsNCiANCkBAIC0xMTIsMTUgKzExMiwyMyBAQCBzdGF0aWMgaW50IG10a19qcGVnX2Vu dW1fZm10KHN0cnVjdCBtdGtfanBlZ19mbXQgKm10a19qcGVnX2Zvcm1hdHMsIGludCBuLA0KIHN0 YXRpYyBpbnQgbXRrX2pwZWdfZW51bV9mbXRfdmlkX2NhcChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9p ZCAqcHJpdiwNCiAJCQkJICAgICBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KIHsNCi0JcmV0dXJu IG10a19qcGVnX2VudW1fZm10KG10a19qcGVnX2RlY19mb3JtYXRzLCBNVEtfSlBFR19ERUNfTlVN X0ZPUk1BVFMsDQotCQkJCSBmLCBNVEtfSlBFR19GTVRfRkxBR19DQVBUVVJFKTsNCisJc3RydWN0 IG10a19qcGVnX2N0eCAqY3R4ID0gbXRrX2pwZWdfZmhfdG9fY3R4KHByaXYpOw0KKwlzdHJ1Y3Qg bXRrX2pwZWdfZGV2ICpqcGVnID0gY3R4LT5qcGVnOw0KKw0KKwlyZXR1cm4gbXRrX2pwZWdfZW51 bV9mbXQoanBlZy0+dmFyaWFudC0+Zm9ybWF0cywNCisJCQkJIGpwZWctPnZhcmlhbnQtPm51bV9m b3JtYXRzLCBmLA0KKwkJCQkgTVRLX0pQRUdfRk1UX0ZMQUdfQ0FQVFVSRSk7DQogfQ0KIA0KIHN0 YXRpYyBpbnQgbXRrX2pwZWdfZW51bV9mbXRfdmlkX291dChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9p ZCAqcHJpdiwNCiAJCQkJICAgICBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KIHsNCi0JcmV0dXJu IG10a19qcGVnX2VudW1fZm10KG10a19qcGVnX2RlY19mb3JtYXRzLCBNVEtfSlBFR19ERUNfTlVN X0ZPUk1BVFMsDQotCQkJCSBmLCBNVEtfSlBFR19GTVRfRkxBR19PVVRQVVQpOw0KKwlzdHJ1Y3Qg bXRrX2pwZWdfY3R4ICpjdHggPSBtdGtfanBlZ19maF90b19jdHgocHJpdik7DQorCXN0cnVjdCBt dGtfanBlZ19kZXYgKmpwZWcgPSBjdHgtPmpwZWc7DQorDQorCXJldHVybiBtdGtfanBlZ19lbnVt X2ZtdChqcGVnLT52YXJpYW50LT5mb3JtYXRzLA0KKwkJCQkganBlZy0+dmFyaWFudC0+bnVtX2Zv cm1hdHMsIGYsDQorCQkJCSBNVEtfSlBFR19GTVRfRkxBR19PVVRQVVQpOw0KIH0NCiANCiBzdGF0 aWMgc3RydWN0IG10a19qcGVnX3FfZGF0YSAqbXRrX2pwZWdfZ2V0X3FfZGF0YShzdHJ1Y3QgbXRr X2pwZWdfY3R4ICpjdHgsDQpAQCAtMjQ0LDEwICsyNTIsMTEgQEAgc3RhdGljIGludCBtdGtfanBl Z190cnlfZm10X3ZpZF9jYXBfbXBsYW5lKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0K IAkJCQkJICAgc3RydWN0IHY0bDJfZm9ybWF0ICpmKQ0KIHsNCiAJc3RydWN0IG10a19qcGVnX2N0 eCAqY3R4ID0gbXRrX2pwZWdfZmhfdG9fY3R4KHByaXYpOw0KKwlzdHJ1Y3QgbXRrX2pwZWdfZGV2 ICpqcGVnID0gY3R4LT5qcGVnOw0KIAlzdHJ1Y3QgbXRrX2pwZWdfZm10ICpmbXQ7DQogDQotCWZt dCA9IG10a19qcGVnX2ZpbmRfZm9ybWF0KG10a19qcGVnX2RlY19mb3JtYXRzLA0KLQkJCQkgICBN VEtfSlBFR19ERUNfTlVNX0ZPUk1BVFMsDQorCWZtdCA9IG10a19qcGVnX2ZpbmRfZm9ybWF0KGpw ZWctPnZhcmlhbnQtPmZvcm1hdHMsDQorCQkJCSAgIGpwZWctPnZhcmlhbnQtPm51bV9mb3JtYXRz LA0KIAkJCQkgICBmLT5mbXQucGl4X21wLnBpeGVsZm9ybWF0LA0KIAkJCQkgICBNVEtfSlBFR19G TVRfRkxBR19DQVBUVVJFKTsNCiAJaWYgKCFmbXQpDQpAQCAtMjcyLDEwICsyODEsMTEgQEAgc3Rh dGljIGludCBtdGtfanBlZ190cnlfZm10X3ZpZF9vdXRfbXBsYW5lKHN0cnVjdCBmaWxlICpmaWxl LCB2b2lkICpwcml2LA0KIAkJCQkJICAgc3RydWN0IHY0bDJfZm9ybWF0ICpmKQ0KIHsNCiAJc3Ry dWN0IG10a19qcGVnX2N0eCAqY3R4ID0gbXRrX2pwZWdfZmhfdG9fY3R4KHByaXYpOw0KKwlzdHJ1 Y3QgbXRrX2pwZWdfZGV2ICpqcGVnID0gY3R4LT5qcGVnOw0KIAlzdHJ1Y3QgbXRrX2pwZWdfZm10 ICpmbXQ7DQogDQotCWZtdCA9IG10a19qcGVnX2ZpbmRfZm9ybWF0KG10a19qcGVnX2RlY19mb3Jt YXRzLA0KLQkJCQkgICBNVEtfSlBFR19ERUNfTlVNX0ZPUk1BVFMsDQorCWZtdCA9IG10a19qcGVn X2ZpbmRfZm9ybWF0KGpwZWctPnZhcmlhbnQtPmZvcm1hdHMsDQorCQkJCSAgIGpwZWctPnZhcmlh bnQtPm51bV9mb3JtYXRzLA0KIAkJCQkgICBmLT5mbXQucGl4X21wLnBpeGVsZm9ybWF0LA0KIAkJ CQkgICBNVEtfSlBFR19GTVRfRkxBR19PVVRQVVQpOw0KIAlpZiAoIWZtdCkNCkBAIC0zMTYsOSAr MzI2LDggQEAgc3RhdGljIGludCBtdGtfanBlZ19zX2ZtdF9tcGxhbmUoc3RydWN0IG10a19qcGVn X2N0eCAqY3R4LA0KIAkJcmV0dXJuIC1FQlVTWTsNCiAJfQ0KIA0KLQ0KLQlxX2RhdGEtPmZtdCA9 IG10a19qcGVnX2ZpbmRfZm9ybWF0KG10a19qcGVnX2RlY19mb3JtYXRzLA0KLQkJCQkJICAgTVRL X0pQRUdfREVDX05VTV9GT1JNQVRTLA0KKwlxX2RhdGEtPmZtdCA9IG10a19qcGVnX2ZpbmRfZm9y bWF0KGpwZWctPnZhcmlhbnQtPmZvcm1hdHMsDQorCQkJCQkgICBqcGVnLT52YXJpYW50LT5udW1f Zm9ybWF0cywNCiAJCQkJCSAgIHBpeF9tcC0+cGl4ZWxmb3JtYXQsIGZtdF90eXBlKTsNCiAJcV9k YXRhLT5waXhfbXAud2lkdGggPSBwaXhfbXAtPndpZHRoOw0KIAlxX2RhdGEtPnBpeF9tcC5oZWln aHQgPSBwaXhfbXAtPmhlaWdodDsNCkBAIC01MTksOSArNTI4LDEwIEBAIHN0YXRpYyBib29sIG10 a19qcGVnX2NoZWNrX3Jlc29sdXRpb25fY2hhbmdlKHN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCwN CiAJfQ0KIA0KIAlxX2RhdGEgPSAmY3R4LT5jYXBfcTsNCi0JaWYgKHFfZGF0YS0+Zm10ICE9IG10 a19qcGVnX2ZpbmRfZm9ybWF0KG10a19qcGVnX2RlY19mb3JtYXRzLA0KLQkJCU1US19KUEVHX0RF Q19OVU1fRk9STUFUUywgcGFyYW0tPmRzdF9mb3VyY2MsDQotCQkJTVRLX0pQRUdfRk1UX0ZMQUdf Q0FQVFVSRSkpIHsNCisJaWYgKHFfZGF0YS0+Zm10ICE9DQorCSAgICBtdGtfanBlZ19maW5kX2Zv cm1hdChqcGVnLT52YXJpYW50LT5mb3JtYXRzLA0KKwkJCQkganBlZy0+dmFyaWFudC0+bnVtX2Zv cm1hdHMsIHBhcmFtLT5kc3RfZm91cmNjLA0KKwkJCQkgTVRLX0pQRUdfRk1UX0ZMQUdfQ0FQVFVS RSkpIHsNCiAJCXY0bDJfZGJnKDEsIGRlYnVnLCAmanBlZy0+djRsMl9kZXYsICJmb3JtYXQgY2hh bmdlXG4iKTsNCiAJCXJldHVybiB0cnVlOw0KIAl9DQpAQCAtNTQyLDggKzU1Miw4IEBAIHN0YXRp YyB2b2lkIG10a19qcGVnX3NldF9xdWV1ZV9kYXRhKHN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCwN CiAJcV9kYXRhID0gJmN0eC0+Y2FwX3E7DQogCXFfZGF0YS0+cGl4X21wLndpZHRoID0gcGFyYW0t PmRlY193Ow0KIAlxX2RhdGEtPnBpeF9tcC5oZWlnaHQgPSBwYXJhbS0+ZGVjX2g7DQotCXFfZGF0 YS0+Zm10ID0gbXRrX2pwZWdfZmluZF9mb3JtYXQobXRrX2pwZWdfZGVjX2Zvcm1hdHMsDQotCQkJ CQkgICBNVEtfSlBFR19ERUNfTlVNX0ZPUk1BVFMsDQorCXFfZGF0YS0+Zm10ID0gbXRrX2pwZWdf ZmluZF9mb3JtYXQoanBlZy0+dmFyaWFudC0+Zm9ybWF0cywNCisJCQkJCSAgIGpwZWctPnZhcmlh bnQtPm51bV9mb3JtYXRzLA0KIAkJCQkJICAgcGFyYW0tPmRzdF9mb3VyY2MsDQogCQkJCQkgICBN VEtfSlBFR19GTVRfRkxBR19DQVBUVVJFKTsNCiANCkBAIC03NDksMTMgKzc1OSwxNCBAQCBzdGF0 aWMgaW50IG10a19qcGVnX3F1ZXVlX2luaXQodm9pZCAqcHJpdiwgc3RydWN0IHZiMl9xdWV1ZSAq c3JjX3ZxLA0KIAkJCSAgICAgICBzdHJ1Y3QgdmIyX3F1ZXVlICpkc3RfdnEpDQogew0KIAlzdHJ1 Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSBwcml2Ow0KKwlzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpqcGVn ID0gY3R4LT5qcGVnOw0KIAlpbnQgcmV0Ow0KIA0KIAlzcmNfdnEtPnR5cGUgPSBWNEwyX0JVRl9U WVBFX1ZJREVPX09VVFBVVF9NUExBTkU7DQogCXNyY192cS0+aW9fbW9kZXMgPSBWQjJfRE1BQlVG IHwgVkIyX01NQVA7DQogCXNyY192cS0+ZHJ2X3ByaXYgPSBjdHg7DQogCXNyY192cS0+YnVmX3N0 cnVjdF9zaXplID0gc2l6ZW9mKHN0cnVjdCBtdGtfanBlZ19zcmNfYnVmKTsNCi0Jc3JjX3ZxLT5v cHMgPSAmbXRrX2pwZWdfZGVjX3FvcHM7DQorCXNyY192cS0+b3BzID0ganBlZy0+dmFyaWFudC0+ cW9wczsNCiAJc3JjX3ZxLT5tZW1fb3BzID0gJnZiMl9kbWFfY29udGlnX21lbW9wczsNCiAJc3Jj X3ZxLT50aW1lc3RhbXBfZmxhZ3MgPSBWNEwyX0JVRl9GTEFHX1RJTUVTVEFNUF9DT1BZOw0KIAlz cmNfdnEtPmxvY2sgPSAmY3R4LT5qcGVnLT5sb2NrOw0KQEAgLTc2OCw3ICs3NzksNyBAQCBzdGF0 aWMgaW50IG10a19qcGVnX3F1ZXVlX2luaXQodm9pZCAqcHJpdiwgc3RydWN0IHZiMl9xdWV1ZSAq c3JjX3ZxLA0KIAlkc3RfdnEtPmlvX21vZGVzID0gVkIyX0RNQUJVRiB8IFZCMl9NTUFQOw0KIAlk c3RfdnEtPmRydl9wcml2ID0gY3R4Ow0KIAlkc3RfdnEtPmJ1Zl9zdHJ1Y3Rfc2l6ZSA9IHNpemVv ZihzdHJ1Y3QgdjRsMl9tMm1fYnVmZmVyKTsNCi0JZHN0X3ZxLT5vcHMgPSAmbXRrX2pwZWdfZGVj X3FvcHM7DQorCWRzdF92cS0+b3BzID0ganBlZy0+dmFyaWFudC0+cW9wczsNCiAJZHN0X3ZxLT5t ZW1fb3BzID0gJnZiMl9kbWFfY29udGlnX21lbW9wczsNCiAJZHN0X3ZxLT50aW1lc3RhbXBfZmxh Z3MgPSBWNEwyX0JVRl9GTEFHX1RJTUVTVEFNUF9DT1BZOw0KIAlkc3RfdnEtPmxvY2sgPSAmY3R4 LT5qcGVnLT5sb2NrOw0KQEAgLTc4NiwxNCArNzk3LDE2IEBAIHN0YXRpYyB2b2lkIG10a19qcGVn X2Nsa19vbihzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpqcGVnKQ0KIAlpZiAocmV0KQ0KIAkJZGV2X2Vy cihqcGVnLT5kZXYsICJtdGtfc21pX2xhcmJfZ2V0IGxhcmJ2ZGVjIGZhaWwgJWRcbiIsIHJldCk7 DQogDQotCXJldCA9IGNsa19idWxrX3ByZXBhcmVfZW5hYmxlKGpwZWctPm51bV9jbGtzLCBqcGVn LT5jbGtzKTsNCisJcmV0ID0gY2xrX2J1bGtfcHJlcGFyZV9lbmFibGUoanBlZy0+dmFyaWFudC0+ bnVtX2Nsa3MsDQorCQkJCSAgICAgIGpwZWctPnZhcmlhbnQtPmNsa3MpOw0KIAlpZiAocmV0KQ0K IAkJZGV2X2VycihqcGVnLT5kZXYsICJGYWlsZWQgdG8gb3BlbiBqcGVnIGNsazogJWRcbiIsIHJl dCk7DQogfQ0KIA0KIHN0YXRpYyB2b2lkIG10a19qcGVnX2Nsa19vZmYoc3RydWN0IG10a19qcGVn X2RldiAqanBlZykNCiB7DQotCWNsa19idWxrX2Rpc2FibGVfdW5wcmVwYXJlKGpwZWctPm51bV9j bGtzLCBqcGVnLT5jbGtzKTsNCisJY2xrX2J1bGtfZGlzYWJsZV91bnByZXBhcmUoanBlZy0+dmFy aWFudC0+bnVtX2Nsa3MsDQorCQkJCSAgIGpwZWctPnZhcmlhbnQtPmNsa3MpOw0KIAltdGtfc21p X2xhcmJfcHV0KGpwZWctPmxhcmIpOw0KIH0NCiANCkBAIC04NDcsMjQgKzg2MCwyNSBAQCBzdGF0 aWMgaXJxcmV0dXJuX3QgbXRrX2pwZWdfZGVjX2lycShpbnQgaXJxLCB2b2lkICpwcml2KQ0KIHN0 YXRpYyB2b2lkIG10a19qcGVnX3NldF9kZWZhdWx0X3BhcmFtcyhzdHJ1Y3QgbXRrX2pwZWdfY3R4 ICpjdHgpDQogew0KIAlzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhICpxID0gJmN0eC0+b3V0X3E7DQor CXN0cnVjdCBtdGtfanBlZ19kZXYgKmpwZWcgPSBjdHgtPmpwZWc7DQogDQogCXEtPnBpeF9tcC5j b2xvcnNwYWNlID0gVjRMMl9DT0xPUlNQQUNFX1NSR0I7DQogCXEtPnBpeF9tcC55Y2Jjcl9lbmMg PSBWNEwyX1lDQkNSX0VOQ182MDE7DQogCXEtPnBpeF9tcC5xdWFudGl6YXRpb24gPSBWNEwyX1FV QU5USVpBVElPTl9GVUxMX1JBTkdFOw0KIAlxLT5waXhfbXAueGZlcl9mdW5jID0gVjRMMl9YRkVS X0ZVTkNfU1JHQjsNCiANCi0JcS0+Zm10ID0gbXRrX2pwZWdfZmluZF9mb3JtYXQobXRrX2pwZWdf ZGVjX2Zvcm1hdHMsDQotCQkJCSAgICAgIE1US19KUEVHX0RFQ19OVU1fRk9STUFUUywNCi0JCQkJ ICAgICAgVjRMMl9QSVhfRk1UX0pQRUcsDQorCXEtPmZtdCA9IG10a19qcGVnX2ZpbmRfZm9ybWF0 KGpwZWctPnZhcmlhbnQtPmZvcm1hdHMsDQorCQkJCSAgICAgIGpwZWctPnZhcmlhbnQtPm51bV9m b3JtYXRzLA0KKwkJCQkgICAgICBqcGVnLT52YXJpYW50LT5vdXRfcV9kZWZhdWx0X2ZvdXJjYywN CiAJCQkJICAgICAgTVRLX0pQRUdfRk1UX0ZMQUdfT1VUUFVUKTsNCiAJcS0+cGl4X21wLndpZHRo ID0gTVRLX0pQRUdfTUlOX1dJRFRIOw0KIAlxLT5waXhfbXAuaGVpZ2h0ID0gTVRLX0pQRUdfTUlO X0hFSUdIVDsNCiAJbXRrX2pwZWdfdHJ5X2ZtdF9tcGxhbmUoJnEtPnBpeF9tcCwgcS0+Zm10KTsN CiANCiAJcSA9ICZjdHgtPmNhcF9xOw0KLQlxLT5mbXQgPSBtdGtfanBlZ19maW5kX2Zvcm1hdCht dGtfanBlZ19kZWNfZm9ybWF0cywNCi0JCQkJICAgICAgTVRLX0pQRUdfREVDX05VTV9GT1JNQVRT LA0KLQkJCQkgICAgICBWNEwyX1BJWF9GTVRfWVVWNDIwTSwNCisJcS0+Zm10ID0gbXRrX2pwZWdf ZmluZF9mb3JtYXQoanBlZy0+dmFyaWFudC0+Zm9ybWF0cywNCisJCQkJICAgICAganBlZy0+dmFy aWFudC0+bnVtX2Zvcm1hdHMsDQorCQkJCSAgICAgIGpwZWctPnZhcmlhbnQtPmNhcF9xX2RlZmF1 bHRfZm91cmNjLA0KIAkJCQkgICAgICBNVEtfSlBFR19GTVRfRkxBR19DQVBUVVJFKTsNCiAJcS0+ cGl4X21wLmNvbG9yc3BhY2UgPSBWNEwyX0NPTE9SU1BBQ0VfU1JHQjsNCiAJcS0+cGl4X21wLnlj YmNyX2VuYyA9IFY0TDJfWUNCQ1JfRU5DXzYwMTsNCkBAIC05NjMsOSArOTc3LDggQEAgc3RhdGlj IGludCBtdGtfanBlZ19jbGtfaW5pdChzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpqcGVnKQ0KIA0KIAlq cGVnLT5sYXJiID0gJnBkZXYtPmRldjsNCiANCi0JanBlZy0+Y2xrcyA9IG10ODE3M19qcGVnX2Rl Y19jbG9ja3M7DQotCWpwZWctPm51bV9jbGtzID0gQVJSQVlfU0laRShtdDgxNzNfanBlZ19kZWNf Y2xvY2tzKTsNCi0JcmV0ID0gZGV2bV9jbGtfYnVsa19nZXQoanBlZy0+ZGV2LCBqcGVnLT5udW1f Y2xrcywganBlZy0+Y2xrcyk7DQorCXJldCA9IGRldm1fY2xrX2J1bGtfZ2V0KGpwZWctPmRldiwg anBlZy0+dmFyaWFudC0+bnVtX2Nsa3MsDQorCQkJCWpwZWctPnZhcmlhbnQtPmNsa3MpOw0KIAlp ZiAocmV0KSB7DQogCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0IGpwZWcgY2xv Y2s6JWRcbiIsIHJldCk7DQogCQlyZXR1cm4gcmV0Ow0KQEAgLTk4NSw3ICs5OTgsNyBAQCBzdGF0 aWMgdm9pZCBtdGtfanBlZ19qb2JfdGltZW91dF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29y aykNCiAJc3JjX2J1ZiA9IHY0bDJfbTJtX3NyY19idWZfcmVtb3ZlKGN0eC0+ZmgubTJtX2N0eCk7 DQogCWRzdF9idWYgPSB2NGwyX20ybV9kc3RfYnVmX3JlbW92ZShjdHgtPmZoLm0ybV9jdHgpOw0K IA0KLQltdGtfanBlZ19kZWNfcmVzZXQoanBlZy0+cmVnX2Jhc2UpOw0KKwlqcGVnLT52YXJpYW50 LT5od19yZXNldChqcGVnLT5yZWdfYmFzZSk7DQogDQogCXBtX3J1bnRpbWVfcHV0KGpwZWctPmRl dik7DQogDQpAQCAtMTAwNyw2ICsxMDIwLDcgQEAgc3RhdGljIGludCBtdGtfanBlZ19wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KIAltdXRleF9pbml0KCZqcGVnLT5sb2NrKTsN CiAJc3Bpbl9sb2NrX2luaXQoJmpwZWctPmh3X2xvY2spOw0KIAlqcGVnLT5kZXYgPSAmcGRldi0+ ZGV2Ow0KKwlqcGVnLT52YXJpYW50ID0gb2ZfZGV2aWNlX2dldF9tYXRjaF9kYXRhKGpwZWctPmRl dik7DQogCUlOSVRfREVMQVlFRF9XT1JLKCZqcGVnLT5qb2JfdGltZW91dF93b3JrLCBtdGtfanBl Z19qb2JfdGltZW91dF93b3JrKTsNCiANCiAJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBk ZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsNCkBAIC0xMDIyLDggKzEwMzYsOCBAQCBzdGF0aWMgaW50 IG10a19qcGVnX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQogCQlyZXR1cm4g anBlZ19pcnE7DQogCX0NCiANCi0JcmV0ID0gZGV2bV9yZXF1ZXN0X2lycSgmcGRldi0+ZGV2LCBq cGVnX2lycSwgbXRrX2pwZWdfZGVjX2lycSwgMCwNCi0JCQkgICAgICAgcGRldi0+bmFtZSwganBl Zyk7DQorCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwganBlZ19pcnEsDQorCQkJ ICAgICAgIGpwZWctPnZhcmlhbnQtPmlycV9oYW5kbGVyLCAwLCBwZGV2LT5uYW1lLCBqcGVnKTsN CiAJaWYgKHJldCkgew0KIAkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIHJlcXVlc3Qg anBlZ19pcnEgJWQgKCVkKVxuIiwNCiAJCQlqcGVnX2lycSwgcmV0KTsNCkBAIC0xMDQzLDcgKzEw NTcsOCBAQCBzdGF0aWMgaW50IG10a19qcGVnX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBkZXYpDQogCQlnb3RvIGVycl9kZXZfcmVnaXN0ZXI7DQogCX0NCiANCi0JanBlZy0+bTJtX2Rl diA9IHY0bDJfbTJtX2luaXQoJm10a19qcGVnX2RlY19tMm1fb3BzKTsNCisJanBlZy0+bTJtX2Rl diA9IHY0bDJfbTJtX2luaXQoanBlZy0+dmFyaWFudC0+bTJtX29wcyk7DQorDQogCWlmIChJU19F UlIoanBlZy0+bTJtX2RldikpIHsNCiAJCXY0bDJfZXJyKCZqcGVnLT52NGwyX2RldiwgIkZhaWxl ZCB0byBpbml0IG1lbTJtZW0gZGV2aWNlXG4iKTsNCiAJCXJldCA9IFBUUl9FUlIoanBlZy0+bTJt X2Rldik7DQpAQCAtMTA1Niw5ICsxMDcxLDkgQEAgc3RhdGljIGludCBtdGtfanBlZ19wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KIAkJZ290byBlcnJfdmZkX2pwZWdfYWxsb2M7 DQogCX0NCiAJc25wcmludGYoanBlZy0+dmRldi0+bmFtZSwgc2l6ZW9mKGpwZWctPnZkZXYtPm5h bWUpLA0KLQkJICIlcy1kZWMiLCBNVEtfSlBFR19OQU1FKTsNCisJCSAiJXMiLCBqcGVnLT52YXJp YW50LT5kZXZfbmFtZSk7DQogCWpwZWctPnZkZXYtPmZvcHMgPSAmbXRrX2pwZWdfZm9wczsNCi0J anBlZy0+dmRldi0+aW9jdGxfb3BzID0gJm10a19qcGVnX2RlY19pb2N0bF9vcHM7DQorCWpwZWct PnZkZXYtPmlvY3RsX29wcyA9IGpwZWctPnZhcmlhbnQtPmlvY3RsX29wczsNCiAJanBlZy0+dmRl di0+bWlub3IgPSAtMTsNCiAJanBlZy0+dmRldi0+cmVsZWFzZSA9IHZpZGVvX2RldmljZV9yZWxl YXNlOw0KIAlqcGVnLT52ZGV2LT5sb2NrID0gJmpwZWctPmxvY2s7DQpAQCAtMTA3NSw4ICsxMDkw LDkgQEAgc3RhdGljIGludCBtdGtfanBlZ19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2KQ0KIA0KIAl2aWRlb19zZXRfZHJ2ZGF0YShqcGVnLT52ZGV2LCBqcGVnKTsNCiAJdjRsMl9p bmZvKCZqcGVnLT52NGwyX2RldiwNCi0JCSAgImRlY29kZXIgZGV2aWNlIHJlZ2lzdGVyZWQgYXMg L2Rldi92aWRlbyVkICglZCwlZClcbiIsDQotCQkgIGpwZWctPnZkZXYtPm51bSwgVklERU9fTUFK T1IsIGpwZWctPnZkZXYtPm1pbm9yKTsNCisJCSAgIiVzIGRldmljZSByZWdpc3RlcmVkIGFzIC9k ZXYvdmlkZW8lZCAoJWQsJWQpXG4iLA0KKwkJICBqcGVnLT52YXJpYW50LT5kZXZfbmFtZSwganBl Zy0+dmRldi0+bnVtLA0KKwkJICBWSURFT19NQUpPUiwganBlZy0+dmRldi0+bWlub3IpOw0KIA0K IAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBqcGVnKTsNCiANCkBAIC0xMTU5LDE0ICsxMTc1 LDI5IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyBtdGtfanBlZ19wbV9vcHMgPSB7 DQogCVNFVF9SVU5USU1FX1BNX09QUyhtdGtfanBlZ19wbV9zdXNwZW5kLCBtdGtfanBlZ19wbV9y ZXN1bWUsIE5VTEwpDQogfTsNCiANCitzdGF0aWMgY29uc3Qgc3RydWN0IG10a19qcGVnX3Zhcmlh bnQgbXQ4MTczX2pwZWdfZHJ2ZGF0YSA9IHsNCisJLmNsa3MgPSBtdDgxNzNfanBlZ19kZWNfY2xv Y2tzLA0KKwkubnVtX2Nsa3MgPSBBUlJBWV9TSVpFKG10ODE3M19qcGVnX2RlY19jbG9ja3MpLA0K KwkuZm9ybWF0cyA9IG10a19qcGVnX2RlY19mb3JtYXRzLA0KKwkubnVtX2Zvcm1hdHMgPSBNVEtf SlBFR19ERUNfTlVNX0ZPUk1BVFMsDQorCS5xb3BzID0gJm10a19qcGVnX2RlY19xb3BzLA0KKwku aXJxX2hhbmRsZXIgPSBtdGtfanBlZ19kZWNfaXJxLA0KKwkuaHdfcmVzZXQgPSBtdGtfanBlZ19k ZWNfcmVzZXQsDQorCS5tMm1fb3BzID0gJm10a19qcGVnX2RlY19tMm1fb3BzLA0KKwkuZGV2X25h bWUgPSAibXRrLWpwZWctZGVjIiwNCisJLmlvY3RsX29wcyA9ICZtdGtfanBlZ19kZWNfaW9jdGxf b3BzLA0KKwkub3V0X3FfZGVmYXVsdF9mb3VyY2MgPSBWNEwyX1BJWF9GTVRfSlBFRywNCisJLmNh cF9xX2RlZmF1bHRfZm91cmNjID0gVjRMMl9QSVhfRk1UX1lVVjQyME0sDQorfTsNCisNCiBzdGF0 aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBtdGtfanBlZ19tYXRjaFtdID0gew0KIAl7DQog CQkuY29tcGF0aWJsZSA9ICJtZWRpYXRlayxtdDgxNzMtanBnZGVjIiwNCi0JCS5kYXRhICAgICAg ID0gTlVMTCwNCisJCS5kYXRhID0gJm10ODE3M19qcGVnX2RydmRhdGEsDQogCX0sDQogCXsNCiAJ CS5jb21wYXRpYmxlID0gIm1lZGlhdGVrLG10MjcwMS1qcGdkZWMiLA0KLQkJLmRhdGEgICAgICAg PSBOVUxMLA0KKwkJLmRhdGEgPSAmbXQ4MTczX2pwZWdfZHJ2ZGF0YSwNCiAJfSwNCiAJe30sDQog fTsNCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVn X2NvcmUuaCBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5o DQppbmRleCAwZjI3NDgwZGQ5MGQuLmQxMWQzNjZhMjQ3ZSAxMDA2NDQNCi0tLSBhL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5oDQorKysgYi9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2NvcmUuaA0KQEAgLTQxLDYgKzQxLDM2IEBA IGVudW0gbXRrX2pwZWdfY3R4X3N0YXRlIHsNCiAJTVRLX0pQRUdfU09VUkNFX0NIQU5HRSwNCiB9 Ow0KIA0KKy8qKg0KKyAqIG10a19qcGVnX3ZhcmlhbnQgLSBtdGsganBlZyBkcml2ZXIgdmFyaWFu dA0KKyAqIEBjbGtzOgkJCWNsb2NrIG5hbWVzDQorICogQG51bV9jbGtzOgkJCW51bWJlcnMgb2Yg Y2xvY2sNCisgKiBAZm9ybWF0OgkJCWpwZWcgZHJpdmVyJ3MgaW50ZXJuYWwgY29sb3IgZm9ybWF0 DQorICogQG51bV9mb3JtYXQ6CQkJbnVtYmVyIG9mIGZvcm1hdA0KKyAqIEBxb3BzOgkJCXRoZSBj YWxsYmFjayBvZiBqcGVnIHZiMl9vcHMNCisgKiBAaXJxX2hhbmRsZXI6CQlqcGVnIGlycSBoYW5k bGVyIGNhbGxiYWNrDQorICogQGh3X3Jlc2V0OgkJCWpwZWcgaGFyZHdhcmUgcmVzZXQgY2FsbGJh Y2sNCisgKiBAbTJtX29wczoJCQl0aGUgY2FsbGJhY2sgb2YganBlZyB2NGwyX20ybV9vcHMNCisg KiBAZGV2X25hbWU6CQkJanBlZyBkZXZpY2UgbmFtZQ0KKyAqIEBpb2N0bF9vcHM6CQkJdGhlIGNh bGxiYWNrIG9mIGpwZWcgdjRsMl9pb2N0bF9vcHMNCisgKiBAb3V0X3FfZGVmYXVsdF9mb3VyY2M6 CW91dHB1dCBxdWV1ZSBkZWZhdWx0IGZvdXJjYw0KKyAqIEBjYXBfcV9kZWZhdWx0X2ZvdXJjYzoJ Y2FwdHVyZSBxdWV1ZSBkZWZhdWx0IGZvdXJjYw0KKyAqLw0KK3N0cnVjdCBtdGtfanBlZ192YXJp YW50IHsNCisJc3RydWN0IGNsa19idWxrX2RhdGEgKmNsa3M7DQorCWludCBudW1fY2xrczsNCisJ c3RydWN0IG10a19qcGVnX2ZtdCAqZm9ybWF0czsNCisJaW50IG51bV9mb3JtYXRzOw0KKwljb25z dCBzdHJ1Y3QgdmIyX29wcyAqcW9wczsNCisJaXJxcmV0dXJuX3QgKCppcnFfaGFuZGxlcikoaW50 IGlycSwgdm9pZCAqcHJpdik7DQorCXZvaWQgKCpod19yZXNldCkodm9pZCBfX2lvbWVtICpiYXNl KTsNCisJY29uc3Qgc3RydWN0IHY0bDJfbTJtX29wcyAqbTJtX29wczsNCisJY29uc3QgY2hhciAq ZGV2X25hbWU7DQorCWNvbnN0IHN0cnVjdCB2NGwyX2lvY3RsX29wcyAqaW9jdGxfb3BzOw0KKwl1 MzIgb3V0X3FfZGVmYXVsdF9mb3VyY2M7DQorCXUzMiBjYXBfcV9kZWZhdWx0X2ZvdXJjYzsNCit9 Ow0KKw0KIC8qKg0KICAqIHN0cnVjdCBtdF9qcGVnIC0gSlBFRyBJUCBhYnN0cmFjdGlvbg0KICAq IEBsb2NrOgkJdGhlIG11dGV4IHByb3RlY3RpbmcgdGhpcyBzdHJ1Y3R1cmUNCkBAIC01MiwxMCAr ODIsOSBAQCBlbnVtIG10a19qcGVnX2N0eF9zdGF0ZSB7DQogICogQGFsbG9jX2N0eDoJCXZpZGVv YnVmMiBtZW1vcnkgYWxsb2NhdG9yJ3MgY29udGV4dA0KICAqIEB2ZGV2OgkJdmlkZW8gZGV2aWNl IG5vZGUgZm9yIGpwZWcgbWVtMm1lbSBtb2RlDQogICogQHJlZ19iYXNlOgkJSlBFRyByZWdpc3Rl cnMgbWFwcGluZw0KLSAqIEBjbGtzOgkJY2xvY2sgbmFtZXMNCi0gKiBAbnVtX2Nsa3M6CQludW1i ZXJzIG9mIGNsb2NrDQogICogQGxhcmI6CQlTTUkgZGV2aWNlDQogICogQGpvYl90aW1lb3V0X3dv cms6CUlSUSB0aW1lb3V0IHN0cnVjdHVyZQ0KKyAqIEB2YXJpYW50OgkJZHJpdmVyIHZhcmlhbnQg dG8gYmUgdXNlZA0KICAqLw0KIHN0cnVjdCBtdGtfanBlZ19kZXYgew0KIAlzdHJ1Y3QgbXV0ZXgJ CWxvY2s7DQpAQCAtNjcsMTAgKzk2LDkgQEAgc3RydWN0IG10a19qcGVnX2RldiB7DQogCXZvaWQJ CQkqYWxsb2NfY3R4Ow0KIAlzdHJ1Y3QgdmlkZW9fZGV2aWNlCSp2ZGV2Ow0KIAl2b2lkIF9faW9t ZW0JCSpyZWdfYmFzZTsNCi0Jc3RydWN0IGNsa19idWxrX2RhdGEgKmNsa3M7DQotCWludCBudW1f Y2xrczsNCiAJc3RydWN0IGRldmljZQkJKmxhcmI7DQogCXN0cnVjdCBkZWxheWVkX3dvcmsgam9i X3RpbWVvdXRfd29yazsNCisJY29uc3Qgc3RydWN0IG10a19qcGVnX3ZhcmlhbnQgKnZhcmlhbnQ7 DQogfTsNCiANCiAvKioNCi0tIA0KMi4xOC4wDQo=