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=-9.8 required=3.0 tests=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,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 04471C43603 for ; Wed, 4 Dec 2019 12:48:38 +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 C19952077B for ; Wed, 4 Dec 2019 12:48:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="GnTYcQFs"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="fCWd/G8e" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C19952077B 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=bombadil.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=or4mcKS+rRr5LBTk3WivX49AdRcq/f2GuFvIIFWoOqE=; b=GnTYcQFsBunwN4 eacWmfRJyMbdb6VHrNrL/ra7S3ExecnZgyONCEvUSpth93V7MlDAgrLyQZrx8oyVR7zo4jfRNxC95 3SnW3+gYZV/jljaMI1EVlOWBb8kD/E/JI3OF7rlgLiAOoI5CPR9lQZV/c+gTWdqnoHd68tbxAZZem IEDzreG2yJ4fxJ/nt2fpR5EH4Wu7kzzkOOrZmWd8usQVBBSat5UZrvK8YNfOt41tUcjaSopwcVe5Y 0xQkHMf58/JKyhugg8l2aap7RDiA7gBdH3pNNDcMfx3bipAKHbKBkbrGAH5EF3X5t5JDfAmIUoRG+ rD1sEjw7p3+k+S3FRsvg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1icU57-0004Pi-7h; Wed, 04 Dec 2019 12:48:37 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1icU4R-0003kk-BK; Wed, 04 Dec 2019 12:47:59 +0000 X-UUID: fcb19e25f5114430beb5e0149bc2490c-20191204 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=zochh5N1EFTk7uzD+0ZuSDkeQLR4Al9dvt6pqNoHDGY=; b=fCWd/G8e1nxz2UJAcYorSfWbYy8W6wKzSvs6FXMlltEMUH78j2WFzTTMn9m5fvuAc3mVfiCfhrgq22No3aznXl0pJ75NFWxLZ920BVtgyVEZdP70mAxWMcZbra3bl8xxXoD4RR+P2jN2/YfCKOa++AqA0oMZgWgf8YID/K9rWUU=; X-UUID: fcb19e25f5114430beb5e0149bc2490c-20191204 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 326569526; Wed, 04 Dec 2019 04:47:51 -0800 Received: from MTKMBS06N2.mediatek.inc (172.21.101.130) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Dec 2019 04:48:35 -0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Dec 2019 20:47:48 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Dec 2019 20:46:53 +0800 From: Jerry-ch Chen To: , , , , Subject: [RFC PATCH V4 4/4] platform: mtk-isp: Add Mediatek FD driver Date: Wed, 4 Dec 2019 20:47:32 +0800 Message-ID: <20191204124732.10932-5-Jerry-Ch.chen@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20191204124732.10932-1-Jerry-Ch.chen@mediatek.com> References: <20191204124732.10932-1-Jerry-Ch.chen@mediatek.com> MIME-Version: 1.0 X-TM-SNTS-SMTP: B9A59B929813E828148439615B4C3099B26B454A7EAC0E23C2B41F7CB347283E2000:8 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191204_044755_703499_F3960644 X-CRM114-Status: GOOD ( 15.22 ) 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: devicetree@vger.kernel.org, Sean.Cheng@mediatek.com, Rynn.Wu@mediatek.com, pihsun@chromium.org, srv_heupstream@mediatek.com, Jerry-ch Chen , jungo.lin@mediatek.com, sj.huang@mediatek.com, yuzhao@chromium.org, linux-mediatek@lists.infradead.org, zwisler@chromium.org, christie.yu@mediatek.com, frederic.chen@mediatek.com, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org 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 From: Jerry-ch Chen This patch adds the driver of Face Detection (FD) unit in Mediatek camera system, providing face detection function. The mtk-isp directory will contain drivers for multiple IP blocks found in Mediatek ISP system. It will include ISP Pass 1 driver (CAM), sensor interface driver, DIP driver and face detection driver. Signed-off-by: Jerry-ch Chen --- drivers/media/platform/Kconfig | 2 + drivers/media/platform/Makefile | 2 + drivers/media/platform/mtk-isp/fd/Kconfig | 19 + drivers/media/platform/mtk-isp/fd/Makefile | 5 + drivers/media/platform/mtk-isp/fd/mtk_fd.h | 149 ++ drivers/media/platform/mtk-isp/fd/mtk_fd_40.c | 1279 +++++++++++++++++ include/uapi/linux/v4l2-controls.h | 4 + include/uapi/linux/videodev2.h | 3 + 8 files changed, 1463 insertions(+) create mode 100644 drivers/media/platform/mtk-isp/fd/Kconfig create mode 100644 drivers/media/platform/mtk-isp/fd/Makefile create mode 100644 drivers/media/platform/mtk-isp/fd/mtk_fd.h create mode 100644 drivers/media/platform/mtk-isp/fd/mtk_fd_40.c diff --git a/drivers/media/platform/Kconfig b/drivers/media/platform/Kconfig index a505e9f5a1e2..ae99258e26a5 100644 --- a/drivers/media/platform/Kconfig +++ b/drivers/media/platform/Kconfig @@ -32,6 +32,8 @@ source "drivers/media/platform/davinci/Kconfig" source "drivers/media/platform/omap/Kconfig" +source "drivers/media/platform/mtk-isp/fd/Kconfig" + config VIDEO_ASPEED tristate "Aspeed AST2400 and AST2500 Video Engine driver" depends on VIDEO_V4L2 diff --git a/drivers/media/platform/Makefile b/drivers/media/platform/Makefile index e6deb2597738..8b817cc80f43 100644 --- a/drivers/media/platform/Makefile +++ b/drivers/media/platform/Makefile @@ -94,6 +94,8 @@ obj-$(CONFIG_VIDEO_MEDIATEK_MDP) += mtk-mdp/ obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk-jpeg/ +obj-$(CONFIG_VIDEO_MEDIATEK_FD) += mtk-isp/fd/ + obj-$(CONFIG_VIDEO_QCOM_CAMSS) += qcom/camss/ obj-$(CONFIG_VIDEO_QCOM_VENUS) += qcom/venus/ diff --git a/drivers/media/platform/mtk-isp/fd/Kconfig b/drivers/media/platform/mtk-isp/fd/Kconfig new file mode 100644 index 000000000000..7a747d947e88 --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/Kconfig @@ -0,0 +1,19 @@ +config VIDEO_MEDIATEK_FD + tristate "Mediatek face detection processing function" + depends on VIDEO_V4L2 + depends on ARCH_MEDIATEK + select VIDEOBUF2_DMA_CONTIG + select VIDEOBUF2_CORE + select VIDEOBUF2_V4L2 + select VIDEOBUF2_MEMOPS + select MEDIA_CONTROLLER + select MTK_SCP + + default n + help + Support the Face Detection (FD) feature in the Mediatek + mt8183 Soc. + + FD driver is a V4L2 memory-to-memory device driver which + provides hardware accelerated face detection function, + it can detect different sizes of faces in a raw image. diff --git a/drivers/media/platform/mtk-isp/fd/Makefile b/drivers/media/platform/mtk-isp/fd/Makefile new file mode 100644 index 000000000000..9b1c501d73e1 --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 + +mtk-fd-objs += mtk_fd_40.o + +obj-$(CONFIG_VIDEO_MEDIATEK_FD) += mtk-fd.o \ No newline at end of file diff --git a/drivers/media/platform/mtk-isp/fd/mtk_fd.h b/drivers/media/platform/mtk-isp/fd/mtk_fd.h new file mode 100644 index 000000000000..d85bdcb70d6d --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/mtk_fd.h @@ -0,0 +1,149 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +// +// Copyright (c) 2018 MediaTek Inc. + +#ifndef __MTK_FD_HW_H__ +#define __MTK_FD_HW_H__ + +#include +#include +#include +#include +#include +#include +#include + +#define MTK_FD_OUTPUT_MIN_WIDTH 26U +#define MTK_FD_OUTPUT_MIN_HEIGHT 26U +#define MTK_FD_OUTPUT_MAX_WIDTH 640U +#define MTK_FD_OUTPUT_MAX_HEIGHT 480U + +#define MTK_FD_HW_FMT_VYUY 2 +#define MTK_FD_HW_FMT_UYVY 3 +#define MTK_FD_HW_FMT_YVYU 4 +#define MTK_FD_HW_FMT_YUYV 5 +#define MTK_FD_HW_FMT_YVU_2P 6 +#define MTK_FD_HW_FMT_YUV_2P 7 +#define MTK_FD_HW_FMT_UNKNOWN 8 + +#define MTK_FD_IPI_CMD_INIT 0 +#define MTK_FD_IPI_CMD_INIT_ACK 1 +#define MTK_FD_IPI_CMD_ENQUEUE 2 +#define MTK_FD_IPI_CMD_ENQ_ACK 3 +#define MTK_FD_IPI_CMD_EXIT 4 +#define MTK_FD_IPI_CMD_EXIT_ACK 5 +#define MTK_FD_IPI_CMD_RESET 6 +#define MTK_FD_IPI_CMD_RESET_ACK 7 + +#define MTK_FD_REG_OFFSET_HW_ENABLE 0x4 +#define MTK_FD_REG_OFFSET_INT_EN 0x15c +#define MTK_FD_REG_OFFSET_INT_VAL 0x168 +#define MTK_FD_REG_OFFSET_RESULT 0x178 + +#define MTK_FD_SET_HW_ENABLE 0x111 +#define MTK_FD_RS_BUF_SIZE 2289664 +#define MTK_FD_HW_WORK_BUF_SIZE 0x100000 +#define MTK_FD_MAX_SPEEDUP 7 +#define MTK_FD_MAX_RESULT_NUM 1026 + +/* Max scale size counts */ +#define MTK_FD_SCALE_ARR_NUM 15 + +#define MTK_FD_HW_TIMEOUT 1000 + +enum face_angle { + MTK_FD_FACE_FRONT, + MTK_FD_FACE_RIGHT_50, + MTK_FD_FACE_LEFT_50, + MTK_FD_FACE_RIGHT_90, + MTK_FD_FACE_LEFT_90, + MTK_FD_FACE_ANGLE_NUM, +}; + +struct fd_buffer { + __u32 scp_addr; /* used by SCP */ + __u32 dma_addr; /* used by DMA HW */ +} __packed; + +struct fd_face_result { + char data[16]; +}; + +struct fd_user_output { + struct fd_face_result results[MTK_FD_MAX_RESULT_NUM]; + __u16 number; +}; + +struct user_param { + u8 fd_speedup; + u8 fd_extra_model; + u8 scale_img_num; + u8 src_img_fmt; + __u16 scale_img_width[MTK_FD_SCALE_ARR_NUM]; + __u16 scale_img_height[MTK_FD_SCALE_ARR_NUM]; + __u16 face_directions[MTK_FD_FACE_ANGLE_NUM]; +} __packed; + +struct fd_init_param { + struct fd_buffer fd_manager; + __u32 rs_dma_addr; +} __packed; + +struct fd_enq_param { + __u64 output_vaddr; + struct fd_buffer src_img[2]; + struct fd_buffer user_result; + struct user_param user_param; +} __packed; + +struct fd_ack_param { + __u32 ret_code; + __u32 ret_msg; +} __packed; + +struct ipi_message { + u8 cmd_id; + union { + struct fd_init_param fd_init_param; + struct fd_enq_param fd_enq_param; + struct fd_ack_param fd_ack_param; + }; +} __packed; + +struct mtk_fd_dev { + struct device *dev; + struct mtk_fd_ctx *ctx; + struct v4l2_device v4l2_dev; + struct v4l2_m2m_dev *m2m_dev; + struct media_device mdev; + struct video_device vfd; + struct platform_device *scp_pdev; + struct clk *fd_clk; + struct rproc *rproc_handle; + + /* Lock for V4L2 operations */ + struct mutex vfd_lock; + + struct fd_user_output *output; + struct fd_buffer scp_mem; + void __iomem *fd_base; + void *rs_dma_buf; + dma_addr_t rs_dma_handle; + void *scp_mem_virt_addr; + + u32 fd_stream_count; + struct completion fd_job_finished; + struct delayed_work job_timeout_work; +}; + +struct mtk_fd_ctx { + struct mtk_fd_dev *fd_dev; + struct device *dev; + struct v4l2_fh fh; + struct v4l2_ctrl_handler hdl; + struct v4l2_pix_format_mplane src_fmt; + struct v4l2_meta_format dst_fmt; + struct user_param user_param; +}; + +#endif/*__MTK_FD_HW_H__*/ diff --git a/drivers/media/platform/mtk-isp/fd/mtk_fd_40.c b/drivers/media/platform/mtk-isp/fd/mtk_fd_40.c new file mode 100644 index 000000000000..4364232d7013 --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/mtk_fd_40.c @@ -0,0 +1,1279 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2018 MediaTek Inc. + * + * Author: Jerry-ch Chen + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mtk_fd.h" + +/* Set the face angle and directions to be detected */ +#define V4L2_CID_MTK_FD_DETECT_POSE (V4L2_CID_USER_MTK_FD_BASE + 1) + +/* Set image widths for an input image to be scaled down for face detection */ +#define V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH (V4L2_CID_USER_MTK_FD_BASE + 2) + +/* Set image heights for an input image to be scaled down for face detection */ +#define V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT (V4L2_CID_USER_MTK_FD_BASE + 3) + +/* Set the length of scale down size array */ +#define V4L2_CID_MTK_FD_SCALE_IMG_NUM (V4L2_CID_USER_MTK_FD_BASE + 4) + +/* Set the detection speed, usually reducing accuracy. */ +#define V4L2_CID_MTK_FD_DETECT_SPEED (V4L2_CID_USER_MTK_FD_BASE + 5) + +/* Select the detection model or algorithm to be used. */ +#define V4L2_CID_MTK_FD_DETECTION_MODEL (V4L2_CID_USER_MTK_FD_BASE + 6) + +/* We reserve 16 controls for this driver. */ +#define V4L2_CID_MTK_FD_MAX 16 + +static const struct v4l2_pix_format_mplane mtk_fd_img_fmts[] = { + { + .pixelformat = V4L2_PIX_FMT_VYUY, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_YUYV, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_YVYU, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_UYVY, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_NV16M, + .num_planes = 2, + }, + { + .pixelformat = V4L2_PIX_FMT_NV61M, + .num_planes = 2, + }, +}; + +#define NUM_FORMATS ARRAY_SIZE(mtk_fd_img_fmts) + +static inline struct mtk_fd_ctx *fh_to_ctx(struct v4l2_fh *fh) +{ + return container_of(fh, struct mtk_fd_ctx, fh); +} + +/* */ +static int mtk_fd_hw_alloc_rs_dma_addr(struct mtk_fd_dev *fd) +{ + struct device *dev = fd->dev; + void *va; + dma_addr_t dma_handle; + + va = dma_alloc_coherent(dev, MTK_FD_RS_BUF_SIZE, &dma_handle, + GFP_KERNEL); + if (!va) { + dev_err(dev, "dma_alloc null va\n"); + return -ENOMEM; + } + memset(va, 0, MTK_FD_RS_BUF_SIZE); + fd->rs_dma_buf = va; + fd->rs_dma_handle = dma_handle; + + return 0; +} + +static int mtk_fd_send_ipi_init(struct mtk_fd_dev *fd) +{ + struct ipi_message fd_init_msg; + + fd_init_msg.cmd_id = MTK_FD_IPI_CMD_INIT; + + fd_init_msg.fd_init_param.fd_manager.scp_addr = fd->scp_mem.scp_addr; + fd_init_msg.fd_init_param.fd_manager.dma_addr = fd->scp_mem.dma_addr; + + memset(fd->rs_dma_buf, 0, MTK_FD_RS_BUF_SIZE); + + fd_init_msg.fd_init_param.rs_dma_addr = fd->rs_dma_handle; + + return scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_init_msg, + sizeof(fd_init_msg), 300); +} + +static void mtk_fd_free_dma_handle(struct mtk_fd_dev *fd) +{ + dma_free_coherent(fd->dev, MTK_FD_RS_BUF_SIZE, + fd->rs_dma_buf, + fd->rs_dma_handle); +} + +static int mtk_fd_hw_enable(struct mtk_fd_dev *fd) +{ + int ret; + + pm_runtime_get_sync(fd->dev); + ret = mtk_fd_send_ipi_init(fd); + pm_runtime_put(fd->dev); + if (ret) { + dev_err(fd->dev, "Failed to send fd ipi init\n"); + return ret; + } + return 0; +} + +static void mtk_fd_hw_job_finish(struct mtk_fd_dev *fd, + enum vb2_buffer_state vb_state) +{ + struct mtk_fd_ctx *ctx; + struct vb2_v4l2_buffer *src_vbuf = NULL, *dst_vbuf = NULL; + + pm_runtime_put(fd->dev); + + ctx = v4l2_m2m_get_curr_priv(fd->m2m_dev); + src_vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + + v4l2_m2m_buf_copy_metadata(src_vbuf, dst_vbuf, + V4L2_BUF_FLAG_TSTAMP_SRC_MASK); + v4l2_m2m_buf_done(src_vbuf, vb_state); + v4l2_m2m_buf_done(dst_vbuf, vb_state); + v4l2_m2m_job_finish(fd->m2m_dev, ctx->fh.m2m_ctx); + complete_all(&fd->fd_job_finished); +} + +static void mtk_fd_hw_done(struct mtk_fd_dev *fd, + enum vb2_buffer_state vb_state) +{ + if (!cancel_delayed_work(&fd->job_timeout_work)) + return; + + mtk_fd_hw_job_finish(fd, vb_state); +} + +static void mtk_fd_ipi_handler(void *data, unsigned int len, void *priv) +{ + struct mtk_fd_dev *fd = (struct mtk_fd_dev *)priv; + struct device *dev = fd->dev; + struct ipi_message *fd_ack_msg = (struct ipi_message *)data; + struct fd_ack_param *fd_ack = &fd_ack_msg->fd_ack_param; + + dev_dbg(fd->dev, "fd_ipi_ack_id: %d\n", fd_ack_msg->cmd_id); + switch (fd_ack_msg->cmd_id) { + case MTK_FD_IPI_CMD_INIT_ACK: + return; + case MTK_FD_IPI_CMD_ENQ_ACK: + if (fd_ack->ret_code) { + dev_err(dev, "ipi ret: %d, message: %d\n", + fd_ack->ret_code, fd_ack->ret_msg); + mtk_fd_hw_done(fd, VB2_BUF_STATE_ERROR); + } + return; + case MTK_FD_IPI_CMD_EXIT_ACK: + if (fd_ack->ret_code) + dev_err(dev, "Failed to exit FD HW\n"); + return; + case MTK_FD_IPI_CMD_RESET_ACK: + if (fd_ack->ret_code) + dev_err(dev, "Failed to reset FD HW\n"); + return; + } +} + +static int mtk_fd_hw_connect(struct mtk_fd_dev *fd) +{ + int ret; + + ret = rproc_boot(fd->rproc_handle); + + if (ret < 0) { + /** + * Return 0 if downloading firmware successfully, + * otherwise it is failed + */ + dev_err(fd->dev, "Failed to boot rproc\n"); + return ret; + } + + ret = scp_ipi_register(fd->scp_pdev, SCP_IPI_FD_CMD, + mtk_fd_ipi_handler, fd); + if (ret) { + dev_err(fd->dev, "Failed to register IPI cmd handler\n"); + goto err_rproc_shutdown; + } + + fd->fd_stream_count++; + if (fd->fd_stream_count == 1) { + if (mtk_fd_hw_enable(fd)) { + ret = -EINVAL; + goto err_rproc_shutdown; + } + } + return 0; + +err_rproc_shutdown: + rproc_shutdown(fd->rproc_handle); + return ret; +} + +static void mtk_fd_exit_hw(struct mtk_fd_dev *fd) +{ + struct ipi_message fd_ipi_msg; + + fd_ipi_msg.cmd_id = MTK_FD_IPI_CMD_EXIT; + if (scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_ipi_msg, + sizeof(fd_ipi_msg), 300)) + dev_err(fd->dev, "FD EXIT HW error\n"); +} + +static void mtk_fd_hw_disconnect(struct mtk_fd_dev *fd) +{ + fd->fd_stream_count--; + mtk_fd_exit_hw(fd); + rproc_shutdown(fd->rproc_handle); +} + +static int mtk_fd_hw_job_exec(struct mtk_fd_dev *fd, + struct fd_enq_param *fd_param) +{ + struct ipi_message fd_ipi_msg; + int ret; + + pm_runtime_get_sync((fd->dev)); + + reinit_completion(&fd->fd_job_finished); + schedule_delayed_work(&fd->job_timeout_work, + msecs_to_jiffies(MTK_FD_HW_TIMEOUT)); + + fd_ipi_msg.cmd_id = MTK_FD_IPI_CMD_ENQUEUE; + memcpy(&fd_ipi_msg.fd_enq_param, fd_param, sizeof(struct fd_enq_param)); + ret = scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_ipi_msg, + sizeof(fd_ipi_msg), 300); + if (ret) { + mtk_fd_hw_done(fd, VB2_BUF_STATE_ERROR); + return ret; + } + return 0; +} + +static int mtk_fd_vb2_buf_out_validate(struct vb2_buffer *vb) +{ + struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb); + + if (v4l2_buf->field == V4L2_FIELD_ANY) + v4l2_buf->field = V4L2_FIELD_NONE; + if (v4l2_buf->field != V4L2_FIELD_NONE) + return -EINVAL; + + return 0; +} + +static int mtk_fd_vb2_buf_prepare(struct vb2_buffer *vb) +{ + struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); + struct vb2_queue *vq = vb->vb2_queue; + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + struct device *dev = ctx->dev; + struct v4l2_pix_format_mplane *pixfmt; + + switch (vq->type) { + case V4L2_BUF_TYPE_META_CAPTURE: + if (vb2_plane_size(vb, 0) < ctx->dst_fmt.buffersize) { + dev_dbg(dev, "meta size %lu is too small\n", + vb2_plane_size(vb, 0)); + return -EINVAL; + } + break; + case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + pixfmt = &ctx->src_fmt; + + if (vbuf->field == V4L2_FIELD_ANY) + vbuf->field = V4L2_FIELD_NONE; + + if (vb->num_planes > 2 || vbuf->field != V4L2_FIELD_NONE) { + dev_dbg(dev, "plane %d or field %d not supported\n", + vb->num_planes, vbuf->field); + return -EINVAL; + } + if (vb2_plane_size(vb, 0) < pixfmt->plane_fmt[0].sizeimage) { + dev_dbg(dev, "plane %lu is too small\n", + vb2_plane_size(vb, 0)); + return -EINVAL; + } + break; + } + + return 0; +} + +static void mtk_fd_vb2_buf_queue(struct vb2_buffer *vb) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); + + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); +} + +static int mtk_fd_vb2_queue_setup(struct vb2_queue *vq, + unsigned int *num_buffers, + unsigned int *num_planes, + unsigned int sizes[], + struct device *alloc_devs[]) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + unsigned int size[2]; + unsigned int plane; + + switch (vq->type) { + case V4L2_BUF_TYPE_META_CAPTURE: + size[0] = ctx->dst_fmt.buffersize; + break; + case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + size[0] = ctx->src_fmt.plane_fmt[0].sizeimage; + if (*num_planes == 2) + size[1] = ctx->src_fmt.plane_fmt[1].sizeimage; + break; + } + + if (*num_planes > 2) + return -EINVAL; + if (*num_planes == 0) { + if (vq->type == V4L2_BUF_TYPE_META_CAPTURE) { + sizes[0] = ctx->dst_fmt.buffersize; + *num_planes = 1; + return 0; + } + + *num_planes = ctx->src_fmt.num_planes; + for (plane = 0; plane < *num_planes; plane++) + sizes[plane] = ctx->src_fmt.plane_fmt[plane].sizeimage; + return 0; + } + + for (plane = 0; plane < *num_planes; plane++) { + if (sizes[plane] < size[plane]) + return -EINVAL; + } + return 0; +} + +static int mtk_fd_vb2_start_streaming(struct vb2_queue *vq, unsigned int count) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + + if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) + return mtk_fd_hw_connect(ctx->fd_dev); + else + return 0; +} + +static void mtk_fd_reset_hw(struct mtk_fd_dev *fd) +{ + struct ipi_message fd_ipi_msg; + + fd_ipi_msg.cmd_id = MTK_FD_IPI_CMD_RESET; + if (scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_ipi_msg, + sizeof(fd_ipi_msg), 300)) + dev_err(fd->dev, "FD Reset HW error\n"); +} + +static void mtk_fd_job_timeout_work(struct work_struct *work) +{ + struct mtk_fd_dev *fd = + container_of(work, struct mtk_fd_dev, job_timeout_work.work); + + dev_err(fd->dev, "FD Job timeout!"); + mtk_fd_reset_hw(fd); + mtk_fd_hw_job_finish(fd, VB2_BUF_STATE_ERROR); +} + +static void mtk_fd_job_wait_finish(struct mtk_fd_dev *fd) +{ + wait_for_completion(&fd->fd_job_finished); +} + +static void mtk_fd_vb2_stop_streaming(struct vb2_queue *vq) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + struct mtk_fd_dev *fd = ctx->fd_dev; + struct vb2_v4l2_buffer *vb; + struct v4l2_m2m_ctx *m2m_ctx = ctx->fh.m2m_ctx; + struct v4l2_m2m_queue_ctx *queue_ctx; + + mtk_fd_job_wait_finish(fd); + queue_ctx = V4L2_TYPE_IS_OUTPUT(vq->type) ? + &m2m_ctx->out_q_ctx : + &m2m_ctx->cap_q_ctx; + while ((vb = v4l2_m2m_buf_remove(queue_ctx))) + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); + + if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) + mtk_fd_hw_disconnect(fd); +} + +static void mtk_fd_vb2_request_complete(struct vb2_buffer *vb) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + + v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->hdl); +} + +static int mtk_fd_querycap(struct file *file, void *fh, + struct v4l2_capability *cap) +{ + struct mtk_fd_dev *fd = video_drvdata(file); + struct device *dev = fd->dev; + + strscpy(cap->driver, dev_driver_string(dev), sizeof(cap->driver)); + strscpy(cap->card, dev_driver_string(dev), sizeof(cap->card)); + snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", + dev_name(fd->dev)); + + return 0; +} + +static int mtk_fd_enum_fmt_out_mp(struct file *file, void *fh, + struct v4l2_fmtdesc *f) +{ + if (f->index >= NUM_FORMATS) + return -EINVAL; + + f->pixelformat = mtk_fd_img_fmts[f->index].pixelformat; + return 0; +} + +static void mtk_fd_fill_pixfmt_mp(struct v4l2_pix_format_mplane *dfmt, + const struct v4l2_pix_format_mplane *sfmt) +{ + dfmt->field = V4L2_FIELD_NONE; + dfmt->colorspace = V4L2_COLORSPACE_BT2020; + dfmt->num_planes = sfmt->num_planes; + dfmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; + dfmt->quantization = V4L2_QUANTIZATION_DEFAULT; + dfmt->xfer_func = + V4L2_MAP_XFER_FUNC_DEFAULT(dfmt->colorspace); + + /* Keep user setting as possible */ + dfmt->width = clamp(dfmt->width, + MTK_FD_OUTPUT_MIN_WIDTH, + MTK_FD_OUTPUT_MAX_WIDTH); + dfmt->height = clamp(dfmt->height, + MTK_FD_OUTPUT_MIN_HEIGHT, + MTK_FD_OUTPUT_MAX_HEIGHT); + + if (sfmt->num_planes == 2) { + /* NV16M and NV61M has 1 byte per pixel */ + dfmt->plane_fmt[0].bytesperline = dfmt->width; + dfmt->plane_fmt[1].bytesperline = dfmt->width; + } else { + /* 2 bytes per pixel */ + dfmt->plane_fmt[0].bytesperline = dfmt->width * 2; + } + + dfmt->plane_fmt[0].sizeimage = + dfmt->height * dfmt->plane_fmt[0].bytesperline; +} + +static const struct v4l2_pix_format_mplane *mtk_fd_find_fmt(u32 format) +{ + unsigned int i; + const struct v4l2_pix_format_mplane *dev_fmt; + + for (i = 0; i < NUM_FORMATS; i++) { + dev_fmt = &mtk_fd_img_fmts[i]; + if (dev_fmt->pixelformat == format) + return dev_fmt; + } + + return NULL; +} + +static int mtk_fd_try_fmt_out_mp(struct file *file, + void *fh, + struct v4l2_format *f) +{ + struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; + const struct v4l2_pix_format_mplane *fmt; + + fmt = mtk_fd_find_fmt(pix_mp->pixelformat); + if (!fmt) + fmt = &mtk_fd_img_fmts[0]; /* Get default img fmt */ + + mtk_fd_fill_pixfmt_mp(pix_mp, fmt); + return 0; +} + +static int mtk_fd_g_fmt_out_mp(struct file *file, void *fh, + struct v4l2_format *f) +{ + struct mtk_fd_ctx *ctx = fh_to_ctx(fh); + + f->fmt.pix_mp = ctx->src_fmt; + + return 0; +} + +static int mtk_fd_s_fmt_out_mp(struct file *file, void *fh, + struct v4l2_format *f) +{ + struct mtk_fd_ctx *ctx = fh_to_ctx(fh); + struct vb2_queue *vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); + + /* Change not allowed if queue is streaming. */ + if (vb2_is_streaming(vq)) { + dev_err(ctx->dev, "Failed to set format, vb2 is busy\n"); + return -EBUSY; + } + + mtk_fd_try_fmt_out_mp(file, fh, f); + ctx->src_fmt = f->fmt.pix_mp; + + return 0; +} + +static int mtk_fd_enum_fmt_meta_cap(struct file *file, void *fh, + struct v4l2_fmtdesc *f) +{ + if (f->index) + return -EINVAL; + + strscpy(f->description, "Face detection result", + sizeof(f->description)); + f->pixelformat = V4L2_META_FMT_MTFD_RESULT; + f->flags = 0; + + return 0; +} + +static int mtk_fd_g_fmt_meta_cap(struct file *file, void *fh, + struct v4l2_format *f) +{ + f->fmt.meta.dataformat = V4L2_META_FMT_MTFD_RESULT; + f->fmt.meta.buffersize = sizeof(struct fd_user_output); + + return 0; +} + +static const struct vb2_ops mtk_fd_vb2_ops = { + .queue_setup = mtk_fd_vb2_queue_setup, + .buf_out_validate = mtk_fd_vb2_buf_out_validate, + .buf_prepare = mtk_fd_vb2_buf_prepare, + .buf_queue = mtk_fd_vb2_buf_queue, + .start_streaming = mtk_fd_vb2_start_streaming, + .stop_streaming = mtk_fd_vb2_stop_streaming, + .wait_prepare = vb2_ops_wait_prepare, + .wait_finish = vb2_ops_wait_finish, + .buf_request_complete = mtk_fd_vb2_request_complete, +}; + +static const struct v4l2_ioctl_ops mtk_fd_v4l2_video_out_ioctl_ops = { + .vidioc_querycap = mtk_fd_querycap, + .vidioc_enum_fmt_vid_out = mtk_fd_enum_fmt_out_mp, + .vidioc_g_fmt_vid_out_mplane = mtk_fd_g_fmt_out_mp, + .vidioc_s_fmt_vid_out_mplane = mtk_fd_s_fmt_out_mp, + .vidioc_try_fmt_vid_out_mplane = mtk_fd_try_fmt_out_mp, + .vidioc_enum_fmt_meta_cap = mtk_fd_enum_fmt_meta_cap, + .vidioc_g_fmt_meta_cap = mtk_fd_g_fmt_meta_cap, + .vidioc_s_fmt_meta_cap = mtk_fd_g_fmt_meta_cap, + .vidioc_try_fmt_meta_cap = mtk_fd_g_fmt_meta_cap, + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, + .vidioc_streamon = v4l2_m2m_ioctl_streamon, + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, + .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, +}; + +static int +mtk_fd_queue_init(void *priv, struct vb2_queue *src_vq, + struct vb2_queue *dst_vq) +{ + struct mtk_fd_ctx *ctx = priv; + int ret; + + src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; + src_vq->io_modes = VB2_MMAP | VB2_DMABUF; + src_vq->supports_requests = true; + src_vq->drv_priv = ctx; + src_vq->ops = &mtk_fd_vb2_ops; + src_vq->mem_ops = &vb2_dma_contig_memops; + src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + src_vq->lock = &ctx->fd_dev->vfd_lock; + src_vq->dev = ctx->fd_dev->v4l2_dev.dev; + + ret = vb2_queue_init(src_vq); + if (ret) + return ret; + + dst_vq->type = V4L2_BUF_TYPE_META_CAPTURE; + dst_vq->io_modes = VB2_MMAP | VB2_DMABUF; + dst_vq->drv_priv = ctx; + dst_vq->ops = &mtk_fd_vb2_ops; + dst_vq->mem_ops = &vb2_dma_contig_memops; + dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + dst_vq->lock = &ctx->fd_dev->vfd_lock; + dst_vq->dev = ctx->fd_dev->v4l2_dev.dev; + + return vb2_queue_init(dst_vq); +} + +static struct v4l2_ctrl_config mtk_fd_controls[] = { + { + .id = V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH, + .name = "FD scale image widths", + .type = V4L2_CTRL_TYPE_U16, + .min = MTK_FD_OUTPUT_MIN_WIDTH, + .max = MTK_FD_OUTPUT_MAX_WIDTH, + .step = 1, + .def = MTK_FD_OUTPUT_MAX_WIDTH, + .dims = { MTK_FD_SCALE_ARR_NUM }, + }, + { + .id = V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT, + .name = "FD scale image heights", + .type = V4L2_CTRL_TYPE_U16, + .min = MTK_FD_OUTPUT_MIN_HEIGHT, + .max = MTK_FD_OUTPUT_MAX_HEIGHT, + .step = 1, + .def = MTK_FD_OUTPUT_MAX_HEIGHT, + .dims = { MTK_FD_SCALE_ARR_NUM }, + }, + { + .id = V4L2_CID_MTK_FD_SCALE_IMG_NUM, + .name = "FD scale size counts", + .type = V4L2_CTRL_TYPE_INTEGER, + .min = 0, + .max = MTK_FD_SCALE_ARR_NUM, + .step = 1, + .def = 0, + }, + { + .id = V4L2_CID_MTK_FD_DETECT_POSE, + .name = "FD detect face angle and directions", + .type = V4L2_CTRL_TYPE_U16, + .min = 0, + .max = 0xffff, + .step = 1, + .def = 0x3ff, + .dims = { MTK_FD_FACE_ANGLE_NUM}, + }, + { + .id = V4L2_CID_MTK_FD_DETECT_SPEED, + .name = "FD detection speedup", + .type = V4L2_CTRL_TYPE_INTEGER, + .min = 0, + .max = MTK_FD_MAX_SPEEDUP, + .step = 1, + .def = 0, + }, + { + .id = V4L2_CID_MTK_FD_DETECTION_MODEL, + .name = "FD use extra model", + .type = V4L2_CTRL_TYPE_BOOLEAN, + .min = 0, + .max = 1, + .step = 1, + .def = 0, + }, +}; + +static int mtk_fd_ctrls_setup(struct mtk_fd_ctx *ctx) +{ + struct v4l2_ctrl_handler *hdl = &ctx->hdl; + int i; + + v4l2_ctrl_handler_init(hdl, V4L2_CID_MTK_FD_MAX); + if (hdl->error) + return hdl->error; + + for (i = 0; i < ARRAY_SIZE(mtk_fd_controls); i++) { + v4l2_ctrl_new_custom(hdl, &mtk_fd_controls[i], ctx); + if (hdl->error) { + v4l2_ctrl_handler_free(hdl); + dev_err(ctx->dev, "Failed to register controls:%d", i); + return hdl->error; + } + } + + ctx->fh.ctrl_handler = &ctx->hdl; + v4l2_ctrl_handler_setup(hdl); + + return 0; +} + +static unsigned int get_fd_img_fmt(unsigned int fourcc) +{ + switch (fourcc) { + case V4L2_PIX_FMT_VYUY: + return MTK_FD_HW_FMT_VYUY; + case V4L2_PIX_FMT_YUYV: + return MTK_FD_HW_FMT_YUYV; + case V4L2_PIX_FMT_YVYU: + return MTK_FD_HW_FMT_YVYU; + case V4L2_PIX_FMT_UYVY: + return MTK_FD_HW_FMT_UYVY; + case V4L2_PIX_FMT_NV16M: + return MTK_FD_HW_FMT_YUV_2P; + case V4L2_PIX_FMT_NV61M: + return MTK_FD_HW_FMT_YVU_2P; + default: + return MTK_FD_HW_FMT_UNKNOWN; + } +} + +static void init_ctx_fmt(struct mtk_fd_ctx *ctx) +{ + struct v4l2_pix_format_mplane *src_fmt = &ctx->src_fmt; + struct v4l2_meta_format *dst_fmt = &ctx->dst_fmt; + + /* Initialize M2M source fmt */ + src_fmt->width = MTK_FD_OUTPUT_MAX_WIDTH; + src_fmt->height = MTK_FD_OUTPUT_MAX_HEIGHT; + mtk_fd_fill_pixfmt_mp(src_fmt, &mtk_fd_img_fmts[0]); + + /* Initialize M2M destination fmt */ + dst_fmt->buffersize = sizeof(struct fd_user_output); + dst_fmt->dataformat = V4L2_META_FMT_MTFD_RESULT; +} + +/* + * V4L2 file operations. + */ +static int mtk_vfd_open(struct file *filp) +{ + struct mtk_fd_dev *fd = video_drvdata(filp); + struct video_device *vdev = video_devdata(filp); + struct mtk_fd_ctx *ctx; + int ret; + + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + ctx->fd_dev = fd; + ctx->dev = fd->dev; + fd->ctx = ctx; + + v4l2_fh_init(&ctx->fh, vdev); + filp->private_data = &ctx->fh; + + init_ctx_fmt(ctx); + + ret = mtk_fd_ctrls_setup(ctx); + if (ret) { + dev_err(ctx->dev, "Failed to set up controls:%d\n", ret); + goto err_fh_exit; + } + + ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(fd->m2m_dev, ctx, + &mtk_fd_queue_init); + if (IS_ERR(ctx->fh.m2m_ctx)) { + ret = PTR_ERR(ctx->fh.m2m_ctx); + goto err_free_ctrl_handler; + } + + v4l2_fh_add(&ctx->fh); + + return 0; + +err_free_ctrl_handler: + v4l2_ctrl_handler_free(&ctx->hdl); +err_fh_exit: + v4l2_fh_exit(&ctx->fh); + kfree(ctx); + + return ret; +} + +static int mtk_vfd_release(struct file *filp) +{ + struct mtk_fd_ctx *ctx = container_of(filp->private_data, + struct mtk_fd_ctx, fh); + + v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); + + v4l2_ctrl_handler_free(&ctx->hdl); + v4l2_fh_del(&ctx->fh); + v4l2_fh_exit(&ctx->fh); + + kfree(ctx); + + return 0; +} + +static const struct v4l2_file_operations fd_video_fops = { + .owner = THIS_MODULE, + .open = mtk_vfd_open, + .release = mtk_vfd_release, + .poll = v4l2_m2m_fop_poll, + .unlocked_ioctl = video_ioctl2, + .mmap = v4l2_m2m_fop_mmap, +#ifdef CONFIG_COMPAT + .compat_ioctl32 = v4l2_compat_ioctl32, +#endif + +}; + +static void mtk_fd_fill_user_param(struct user_param *user_param, + struct v4l2_ctrl_handler *hdl) +{ + struct v4l2_ctrl *ctrl; + int i; + + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH); + if (ctrl) + for (i = 0; i < ctrl->elems; i++) + user_param->scale_img_width[i] = ctrl->p_new.p_u16[i]; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT); + if (ctrl) + for (i = 0; i < ctrl->elems; i++) + user_param->scale_img_height[i] = ctrl->p_new.p_u16[i]; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_SCALE_IMG_NUM); + if (ctrl) + user_param->scale_img_num = ctrl->val; + + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_DETECT_POSE); + if (ctrl) + for (i = 0; i < ctrl->elems; i++) + user_param->face_directions[i] = ctrl->p_new.p_u16[i]; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_DETECT_SPEED); + if (ctrl) + user_param->fd_speedup = ctrl->val; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_DETECTION_MODEL); + if (ctrl) + user_param->fd_extra_model = ctrl->val; +} + +static void mtk_fd_device_run(void *priv) +{ + struct mtk_fd_ctx *ctx = priv; + struct mtk_fd_dev *fd = ctx->fd_dev; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + struct fd_enq_param fd_param; + void *plane_vaddr; + + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); + + fd_param.src_img[0].dma_addr = + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0); + fd_param.user_result.dma_addr = + vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0); + plane_vaddr = vb2_plane_vaddr(&dst_buf->vb2_buf, 0); + fd_param.output_vaddr = (u64)(unsigned long)plane_vaddr; + fd_param.user_param.src_img_fmt = + get_fd_img_fmt(ctx->src_fmt.pixelformat); + if (ctx->src_fmt.num_planes == 2) + fd_param.src_img[1].dma_addr = + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 1); + mtk_fd_fill_user_param(&fd_param.user_param, &ctx->hdl); + + /* Complete request controls if any */ + v4l2_ctrl_request_complete(src_buf->vb2_buf.req_obj.req, &ctx->hdl); + + fd->output = plane_vaddr; + mtk_fd_hw_job_exec(fd, &fd_param); +} + +static struct v4l2_m2m_ops fd_m2m_ops = { + .device_run = mtk_fd_device_run, +}; + +static const struct media_device_ops fd_m2m_media_ops = { + .req_validate = vb2_request_validate, + .req_queue = v4l2_m2m_request_queue, +}; + +static int mtk_fd_video_device_register(struct mtk_fd_dev *fd) +{ + struct video_device *vfd = &fd->vfd; + struct v4l2_m2m_dev *m2m_dev = fd->m2m_dev; + struct device *dev = fd->dev; + int ret; + + vfd->fops = &fd_video_fops; + vfd->release = video_device_release; + vfd->lock = &fd->vfd_lock; + vfd->v4l2_dev = &fd->v4l2_dev; + vfd->vfl_dir = VFL_DIR_M2M; + vfd->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT_MPLANE | + V4L2_CAP_META_CAPTURE; + vfd->ioctl_ops = &mtk_fd_v4l2_video_out_ioctl_ops; + + strscpy(vfd->name, dev_driver_string(dev), sizeof(vfd->name)); + + video_set_drvdata(vfd, fd); + + ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0); + if (ret) { + dev_err(dev, "Failed to register video device\n"); + goto err_free_dev; + } + + ret = v4l2_m2m_register_media_controller(m2m_dev, vfd, + MEDIA_ENT_F_PROC_VIDEO_STATISTICS); + if (ret) { + dev_err(dev, "Failed to init mem2mem media controller\n"); + goto err_unreg_video; + } + return 0; + +err_unreg_video: + video_unregister_device(vfd); +err_free_dev: + video_device_release(vfd); + return ret; +} + +static int mtk_fd_dev_v4l2_init(struct mtk_fd_dev *fd) +{ + struct media_device *mdev = &fd->mdev; + struct device *dev = fd->dev; + int ret; + + ret = v4l2_device_register(dev, &fd->v4l2_dev); + if (ret) { + dev_err(dev, "Failed to register v4l2 device\n"); + return ret; + } + + fd->m2m_dev = v4l2_m2m_init(&fd_m2m_ops); + if (IS_ERR(fd->m2m_dev)) { + dev_err(dev, "Failed to init mem2mem device\n"); + ret = PTR_ERR(fd->m2m_dev); + goto err_unreg_v4l2_dev; + } + + mdev->dev = dev; + strscpy(mdev->model, dev_driver_string(dev), sizeof(mdev->model)); + snprintf(mdev->bus_info, sizeof(mdev->bus_info), + "platform:%s", dev_name(dev)); + media_device_init(mdev); + mdev->ops = &fd_m2m_media_ops; + fd->v4l2_dev.mdev = mdev; + + ret = mtk_fd_video_device_register(fd); + if (ret) { + dev_err(dev, "Failed to register video device\n"); + goto err_cleanup_mdev; + } + + ret = media_device_register(mdev); + if (ret) { + dev_err(dev, "Failed to register mem2mem media device\n"); + goto err_unreg_vdev; + } + + return 0; + +err_unreg_vdev: + v4l2_m2m_unregister_media_controller(fd->m2m_dev); + video_unregister_device(&fd->vfd); + video_device_release(&fd->vfd); +err_cleanup_mdev: + media_device_cleanup(mdev); + v4l2_m2m_release(fd->m2m_dev); +err_unreg_v4l2_dev: + v4l2_device_unregister(&fd->v4l2_dev); + return ret; +} + +static void mtk_fd_dev_v4l2_release(struct mtk_fd_dev *fd) +{ + v4l2_m2m_unregister_media_controller(fd->m2m_dev); + video_unregister_device(&fd->vfd); + video_device_release(&fd->vfd); + media_device_cleanup(&fd->mdev); + v4l2_m2m_release(fd->m2m_dev); + v4l2_device_unregister(&fd->v4l2_dev); +} + +static irqreturn_t mtk_fd_irq(int irq, void *data) +{ + struct mtk_fd_dev *fd = (struct mtk_fd_dev *)data; + + /* must read this register otherwise HW will keep sending irq */ + readl(fd->fd_base + MTK_FD_REG_OFFSET_INT_VAL); + fd->output->number = readl(fd->fd_base + MTK_FD_REG_OFFSET_RESULT); + dev_dbg(fd->dev, "mtk_fd_face_num:%d\n", fd->output->number); + + mtk_fd_hw_done(fd, VB2_BUF_STATE_DONE); + return IRQ_HANDLED; +} + +static int mtk_fd_hw_get_scp_mem(struct mtk_fd_dev *fd) +{ + struct device *dev = fd->dev; + dma_addr_t addr; + void *ptr; + u32 ret; + + /* + * Allocate coherent reserved memory for SCP firmware usage. + * The size of SCP composer's memory is fixed to 0x100000 + * for the requirement of firmware. + */ + ptr = dma_alloc_coherent(&fd->scp_pdev->dev, + MTK_FD_HW_WORK_BUF_SIZE, &addr, GFP_KERNEL); + if (!ptr) + return -ENOMEM; + + fd->scp_mem.scp_addr = addr; + fd->scp_mem_virt_addr = ptr; + dev_info(dev, "scp addr:%pad va:%pK\n", &addr, ptr); + + /* + * This reserved memory is also be used by FD HW. + * Need to get iova address for FD DMA. + */ + addr = dma_map_resource(dev, addr, MTK_FD_HW_WORK_BUF_SIZE, + DMA_TO_DEVICE, DMA_ATTR_SKIP_CPU_SYNC); + if (dma_mapping_error(dev, addr)) { + dev_err(dev, "Failed to map scp iova\n"); + ret = -ENOMEM; + goto fail_free_mem; + } + fd->scp_mem.dma_addr = addr; + dev_info(dev, "scp iova addr:%pad\n", &addr); + + return 0; + +fail_free_mem: + dma_free_coherent(&fd->scp_pdev->dev, MTK_FD_HW_WORK_BUF_SIZE, + ptr, fd->scp_mem.scp_addr); + fd->scp_mem.scp_addr = 0; + + return ret; +} + +static int mtk_fd_probe(struct platform_device *pdev) +{ + struct mtk_fd_dev *fd; + struct device *dev = &pdev->dev; + + struct resource *res; + phandle rproc_phandle; + int irq; + int ret; + + fd = devm_kzalloc(&pdev->dev, sizeof(*fd), GFP_KERNEL); + if (!fd) + return -ENOMEM; + + dev_set_drvdata(dev, fd); + fd->dev = dev; + + irq = platform_get_irq(pdev, 0); + if (irq < 0) { + dev_err(dev, "Failed to get irq by platform: %d\n", irq); + return irq; + } + ret = devm_request_irq(dev, irq, mtk_fd_irq, IRQF_SHARED, + dev_driver_string(dev), + fd); + if (ret) { + dev_err(dev, "Failed to request irq\n"); + return ret; + } + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + fd->fd_base = devm_ioremap_resource(dev, res); + if (IS_ERR(fd->fd_base)) { + dev_err(dev, "Failed to get fd reg base\n"); + return PTR_ERR(fd->fd_base); + } + + fd->fd_clk = devm_clk_get(dev, "fd"); + if (IS_ERR(fd->fd_clk)) { + dev_err(dev, "Failed to get fd_clk_img_fd clock\n"); + return PTR_ERR(fd->fd_clk); + } + + /* init scp */ + fd->scp_pdev = scp_get_pdev(pdev); + if (!fd->scp_pdev) { + dev_err(dev, "Failed to get scp device\n"); + return -ENODEV; + } + + if (of_property_read_u32(fd->dev->of_node, "mediatek,scp", + &rproc_phandle)) { + dev_err(dev, "Failed to get scp device\n"); + return -EINVAL; + } + + fd->rproc_handle = rproc_get_by_phandle(rproc_phandle); + if (!fd->rproc_handle) { + dev_err(dev, "Failed to get FD's rproc_handle\n"); + return -EINVAL; + } + + ret = mtk_fd_hw_get_scp_mem(fd); + if (ret) { + dev_err(dev, "Failed to init scp memory: %d\n", ret); + return ret; + } + + ret = mtk_fd_hw_alloc_rs_dma_addr(fd); + if (ret) { + dev_err(dev, "Failed to allocate dma buffer: %d\n", ret); + return ret; + } + + mutex_init(&fd->vfd_lock); + init_completion(&fd->fd_job_finished); + INIT_DELAYED_WORK(&fd->job_timeout_work, mtk_fd_job_timeout_work); + pm_runtime_enable(dev); + + ret = mtk_fd_dev_v4l2_init(fd); + if (ret) { + dev_err(dev, "Failed to init v4l2 device: %d\n", ret); + goto err_destroy_mutex; + } + + return 0; + +err_destroy_mutex: + mutex_destroy(&fd->vfd_lock); + pm_runtime_disable(fd->dev); + mtk_fd_free_dma_handle(fd); + return ret; +} + +static int mtk_fd_remove(struct platform_device *pdev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(&pdev->dev); + + mtk_fd_dev_v4l2_release(fd); + pm_runtime_disable(&pdev->dev); + dma_unmap_page_attrs(fd->dev, + fd->scp_mem.dma_addr, + MTK_FD_HW_WORK_BUF_SIZE, + DMA_TO_DEVICE, + DMA_ATTR_SKIP_CPU_SYNC); + dma_free_coherent(&fd->scp_pdev->dev, + MTK_FD_HW_WORK_BUF_SIZE, + fd->scp_mem_virt_addr, + fd->scp_mem.scp_addr); + mutex_destroy(&fd->vfd_lock); + mtk_fd_free_dma_handle(fd); + rproc_put(fd->rproc_handle); + + return 0; +} + +static int mtk_fd_suspend(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + + if (pm_runtime_suspended(dev)) + return 0; + + v4l2_m2m_suspend(fd->m2m_dev); + + /* suspend FD HW */ + writel(0x0, fd->fd_base + MTK_FD_REG_OFFSET_INT_EN); + writel(0x0, fd->fd_base + MTK_FD_REG_OFFSET_HW_ENABLE); + clk_disable_unprepare(fd->fd_clk); + dev_dbg(dev, "%s:disable clock\n", __func__); + + return 0; +} + +static int mtk_fd_resume(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + int ret; + + if (pm_runtime_suspended(dev)) + return 0; + + ret = clk_prepare_enable(fd->fd_clk); + if (ret < 0) { + dev_dbg(dev, "Failed to open fd clk:%d\n", ret); + return ret; + } + + /* resume FD HW */ + writel(MTK_FD_SET_HW_ENABLE, fd->fd_base + MTK_FD_REG_OFFSET_HW_ENABLE); + writel(0x1, fd->fd_base + MTK_FD_REG_OFFSET_INT_EN); + dev_dbg(dev, "%s:enable clock\n", __func__); + + v4l2_m2m_resume(fd->m2m_dev); + + return 0; +} + +static int mtk_fd_runtime_suspend(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + + clk_disable_unprepare(fd->fd_clk); + return 0; +} + +static int mtk_fd_runtime_resume(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + int ret; + + ret = clk_prepare_enable(fd->fd_clk); + if (ret < 0) { + dev_err(dev, "Failed to open fd clk:%d\n", ret); + return ret; + } + + return 0; +} + +static const struct dev_pm_ops mtk_fd_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(mtk_fd_suspend, mtk_fd_resume) + SET_RUNTIME_PM_OPS(mtk_fd_runtime_suspend, mtk_fd_runtime_resume, NULL) +}; + +static const struct of_device_id mtk_fd_of_ids[] = { + { .compatible = "mediatek,mt8183-fd", }, + {} +}; +MODULE_DEVICE_TABLE(of, mtk_fd_of_ids); + +static struct platform_driver mtk_fd_driver = { + .probe = mtk_fd_probe, + .remove = mtk_fd_remove, + .driver = { + .name = "mtk-fd-4.0", + .of_match_table = of_match_ptr(mtk_fd_of_ids), + .pm = &mtk_fd_pm_ops, + } +}; +module_platform_driver(mtk_fd_driver); +MODULE_AUTHOR("Jerry-ch Chen "); +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("Mediatek FD driver"); diff --git a/include/uapi/linux/v4l2-controls.h b/include/uapi/linux/v4l2-controls.h index 3dcfc6148f99..eae876ea6d0a 100644 --- a/include/uapi/linux/v4l2-controls.h +++ b/include/uapi/linux/v4l2-controls.h @@ -192,6 +192,10 @@ enum v4l2_colorfx { * We reserve 16 controls for this driver. */ #define V4L2_CID_USER_IMX_BASE (V4L2_CID_USER_BASE + 0x10b0) +/* The base for the mediatek FD driver controls */ +/* We reserve 16 controls for this driver. */ +#define V4L2_CID_USER_MTK_FD_BASE (V4L2_CID_USER_BASE + 0x10d0) + /* MPEG-class control IDs */ /* The MPEG controls are applicable to all codec controls * and the 'MPEG' part of the define is historical */ diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h index b5671ce2724f..203e49ebc9e8 100644 --- a/include/uapi/linux/videodev2.h +++ b/include/uapi/linux/videodev2.h @@ -721,6 +721,9 @@ struct v4l2_pix_format { #define V4L2_META_FMT_UVC v4l2_fourcc('U', 'V', 'C', 'H') /* UVC Payload Header metadata */ #define V4L2_META_FMT_D4XX v4l2_fourcc('D', '4', 'X', 'X') /* D4XX Payload Header metadata */ +/* Vendor specific - Mediatek Face Detection meta buffer format for firmware */ +#define V4L2_META_FMT_MTFD_RESULT v4l2_fourcc('M', 'T', 'f', 'd') /* FD meta capture buffer */ + /* priv field value to indicates that subsequent fields are valid. */ #define V4L2_PIX_FMT_PRIV_MAGIC 0xfeedcafe -- 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=-9.8 required=3.0 tests=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,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 9091CC2BC73 for ; Wed, 4 Dec 2019 12:48:45 +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 5701C2077B for ; Wed, 4 Dec 2019 12:48:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="dyLKKLv1"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="fCWd/G8e" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5701C2077B 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+infradead-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=bombadil.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=IRIrJRdnUYYufibB47asM6u8s5zFawqpftMWgAi4Bxw=; b=dyLKKLv1xvSNkD g3RxfjXLrbRLwzZTfbEmR5UGoU1f20gDzTxisXjh9xJzM1oJSANL686cFuR0koToDghITDAyJvOc4 zVc7g6zeL/8maxxdbiJ+HQR8GrxEeQj2WSu5Y3oTwG0rNlFQaLjLrZFB6qcjDlGDiaoOPIRkvHOlg KK+NMOPXlm/NR0El67k/QZ30dJUjmB9QQD/4BaiDtB3BsvtHkYVnZpdPi/hj7an0jsqaJvq5oOH/o u4z4DBUnk3sw0K/QWjmmyjb/V5H2C8tTMv+YgulloY5PIlt8/zsmQ4gNh+LRLE7ZIoklf4kKT+/c1 d6iHZr08IVnH8/JLYk3g==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1icU5D-0004Ui-Pi; Wed, 04 Dec 2019 12:48:43 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1icU4R-0003kk-BK; Wed, 04 Dec 2019 12:47:59 +0000 X-UUID: fcb19e25f5114430beb5e0149bc2490c-20191204 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=zochh5N1EFTk7uzD+0ZuSDkeQLR4Al9dvt6pqNoHDGY=; b=fCWd/G8e1nxz2UJAcYorSfWbYy8W6wKzSvs6FXMlltEMUH78j2WFzTTMn9m5fvuAc3mVfiCfhrgq22No3aznXl0pJ75NFWxLZ920BVtgyVEZdP70mAxWMcZbra3bl8xxXoD4RR+P2jN2/YfCKOa++AqA0oMZgWgf8YID/K9rWUU=; X-UUID: fcb19e25f5114430beb5e0149bc2490c-20191204 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 326569526; Wed, 04 Dec 2019 04:47:51 -0800 Received: from MTKMBS06N2.mediatek.inc (172.21.101.130) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Dec 2019 04:48:35 -0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Dec 2019 20:47:48 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Dec 2019 20:46:53 +0800 From: Jerry-ch Chen To: , , , , Subject: [RFC PATCH V4 4/4] platform: mtk-isp: Add Mediatek FD driver Date: Wed, 4 Dec 2019 20:47:32 +0800 Message-ID: <20191204124732.10932-5-Jerry-Ch.chen@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20191204124732.10932-1-Jerry-Ch.chen@mediatek.com> References: <20191204124732.10932-1-Jerry-Ch.chen@mediatek.com> MIME-Version: 1.0 X-TM-SNTS-SMTP: B9A59B929813E828148439615B4C3099B26B454A7EAC0E23C2B41F7CB347283E2000:8 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191204_044755_703499_F3960644 X-CRM114-Status: GOOD ( 15.22 ) 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: devicetree@vger.kernel.org, Sean.Cheng@mediatek.com, Rynn.Wu@mediatek.com, pihsun@chromium.org, srv_heupstream@mediatek.com, Jerry-ch Chen , jungo.lin@mediatek.com, sj.huang@mediatek.com, yuzhao@chromium.org, linux-mediatek@lists.infradead.org, zwisler@chromium.org, christie.yu@mediatek.com, frederic.chen@mediatek.com, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org From: Jerry-ch Chen This patch adds the driver of Face Detection (FD) unit in Mediatek camera system, providing face detection function. The mtk-isp directory will contain drivers for multiple IP blocks found in Mediatek ISP system. It will include ISP Pass 1 driver (CAM), sensor interface driver, DIP driver and face detection driver. Signed-off-by: Jerry-ch Chen --- drivers/media/platform/Kconfig | 2 + drivers/media/platform/Makefile | 2 + drivers/media/platform/mtk-isp/fd/Kconfig | 19 + drivers/media/platform/mtk-isp/fd/Makefile | 5 + drivers/media/platform/mtk-isp/fd/mtk_fd.h | 149 ++ drivers/media/platform/mtk-isp/fd/mtk_fd_40.c | 1279 +++++++++++++++++ include/uapi/linux/v4l2-controls.h | 4 + include/uapi/linux/videodev2.h | 3 + 8 files changed, 1463 insertions(+) create mode 100644 drivers/media/platform/mtk-isp/fd/Kconfig create mode 100644 drivers/media/platform/mtk-isp/fd/Makefile create mode 100644 drivers/media/platform/mtk-isp/fd/mtk_fd.h create mode 100644 drivers/media/platform/mtk-isp/fd/mtk_fd_40.c diff --git a/drivers/media/platform/Kconfig b/drivers/media/platform/Kconfig index a505e9f5a1e2..ae99258e26a5 100644 --- a/drivers/media/platform/Kconfig +++ b/drivers/media/platform/Kconfig @@ -32,6 +32,8 @@ source "drivers/media/platform/davinci/Kconfig" source "drivers/media/platform/omap/Kconfig" +source "drivers/media/platform/mtk-isp/fd/Kconfig" + config VIDEO_ASPEED tristate "Aspeed AST2400 and AST2500 Video Engine driver" depends on VIDEO_V4L2 diff --git a/drivers/media/platform/Makefile b/drivers/media/platform/Makefile index e6deb2597738..8b817cc80f43 100644 --- a/drivers/media/platform/Makefile +++ b/drivers/media/platform/Makefile @@ -94,6 +94,8 @@ obj-$(CONFIG_VIDEO_MEDIATEK_MDP) += mtk-mdp/ obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk-jpeg/ +obj-$(CONFIG_VIDEO_MEDIATEK_FD) += mtk-isp/fd/ + obj-$(CONFIG_VIDEO_QCOM_CAMSS) += qcom/camss/ obj-$(CONFIG_VIDEO_QCOM_VENUS) += qcom/venus/ diff --git a/drivers/media/platform/mtk-isp/fd/Kconfig b/drivers/media/platform/mtk-isp/fd/Kconfig new file mode 100644 index 000000000000..7a747d947e88 --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/Kconfig @@ -0,0 +1,19 @@ +config VIDEO_MEDIATEK_FD + tristate "Mediatek face detection processing function" + depends on VIDEO_V4L2 + depends on ARCH_MEDIATEK + select VIDEOBUF2_DMA_CONTIG + select VIDEOBUF2_CORE + select VIDEOBUF2_V4L2 + select VIDEOBUF2_MEMOPS + select MEDIA_CONTROLLER + select MTK_SCP + + default n + help + Support the Face Detection (FD) feature in the Mediatek + mt8183 Soc. + + FD driver is a V4L2 memory-to-memory device driver which + provides hardware accelerated face detection function, + it can detect different sizes of faces in a raw image. diff --git a/drivers/media/platform/mtk-isp/fd/Makefile b/drivers/media/platform/mtk-isp/fd/Makefile new file mode 100644 index 000000000000..9b1c501d73e1 --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 + +mtk-fd-objs += mtk_fd_40.o + +obj-$(CONFIG_VIDEO_MEDIATEK_FD) += mtk-fd.o \ No newline at end of file diff --git a/drivers/media/platform/mtk-isp/fd/mtk_fd.h b/drivers/media/platform/mtk-isp/fd/mtk_fd.h new file mode 100644 index 000000000000..d85bdcb70d6d --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/mtk_fd.h @@ -0,0 +1,149 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +// +// Copyright (c) 2018 MediaTek Inc. + +#ifndef __MTK_FD_HW_H__ +#define __MTK_FD_HW_H__ + +#include +#include +#include +#include +#include +#include +#include + +#define MTK_FD_OUTPUT_MIN_WIDTH 26U +#define MTK_FD_OUTPUT_MIN_HEIGHT 26U +#define MTK_FD_OUTPUT_MAX_WIDTH 640U +#define MTK_FD_OUTPUT_MAX_HEIGHT 480U + +#define MTK_FD_HW_FMT_VYUY 2 +#define MTK_FD_HW_FMT_UYVY 3 +#define MTK_FD_HW_FMT_YVYU 4 +#define MTK_FD_HW_FMT_YUYV 5 +#define MTK_FD_HW_FMT_YVU_2P 6 +#define MTK_FD_HW_FMT_YUV_2P 7 +#define MTK_FD_HW_FMT_UNKNOWN 8 + +#define MTK_FD_IPI_CMD_INIT 0 +#define MTK_FD_IPI_CMD_INIT_ACK 1 +#define MTK_FD_IPI_CMD_ENQUEUE 2 +#define MTK_FD_IPI_CMD_ENQ_ACK 3 +#define MTK_FD_IPI_CMD_EXIT 4 +#define MTK_FD_IPI_CMD_EXIT_ACK 5 +#define MTK_FD_IPI_CMD_RESET 6 +#define MTK_FD_IPI_CMD_RESET_ACK 7 + +#define MTK_FD_REG_OFFSET_HW_ENABLE 0x4 +#define MTK_FD_REG_OFFSET_INT_EN 0x15c +#define MTK_FD_REG_OFFSET_INT_VAL 0x168 +#define MTK_FD_REG_OFFSET_RESULT 0x178 + +#define MTK_FD_SET_HW_ENABLE 0x111 +#define MTK_FD_RS_BUF_SIZE 2289664 +#define MTK_FD_HW_WORK_BUF_SIZE 0x100000 +#define MTK_FD_MAX_SPEEDUP 7 +#define MTK_FD_MAX_RESULT_NUM 1026 + +/* Max scale size counts */ +#define MTK_FD_SCALE_ARR_NUM 15 + +#define MTK_FD_HW_TIMEOUT 1000 + +enum face_angle { + MTK_FD_FACE_FRONT, + MTK_FD_FACE_RIGHT_50, + MTK_FD_FACE_LEFT_50, + MTK_FD_FACE_RIGHT_90, + MTK_FD_FACE_LEFT_90, + MTK_FD_FACE_ANGLE_NUM, +}; + +struct fd_buffer { + __u32 scp_addr; /* used by SCP */ + __u32 dma_addr; /* used by DMA HW */ +} __packed; + +struct fd_face_result { + char data[16]; +}; + +struct fd_user_output { + struct fd_face_result results[MTK_FD_MAX_RESULT_NUM]; + __u16 number; +}; + +struct user_param { + u8 fd_speedup; + u8 fd_extra_model; + u8 scale_img_num; + u8 src_img_fmt; + __u16 scale_img_width[MTK_FD_SCALE_ARR_NUM]; + __u16 scale_img_height[MTK_FD_SCALE_ARR_NUM]; + __u16 face_directions[MTK_FD_FACE_ANGLE_NUM]; +} __packed; + +struct fd_init_param { + struct fd_buffer fd_manager; + __u32 rs_dma_addr; +} __packed; + +struct fd_enq_param { + __u64 output_vaddr; + struct fd_buffer src_img[2]; + struct fd_buffer user_result; + struct user_param user_param; +} __packed; + +struct fd_ack_param { + __u32 ret_code; + __u32 ret_msg; +} __packed; + +struct ipi_message { + u8 cmd_id; + union { + struct fd_init_param fd_init_param; + struct fd_enq_param fd_enq_param; + struct fd_ack_param fd_ack_param; + }; +} __packed; + +struct mtk_fd_dev { + struct device *dev; + struct mtk_fd_ctx *ctx; + struct v4l2_device v4l2_dev; + struct v4l2_m2m_dev *m2m_dev; + struct media_device mdev; + struct video_device vfd; + struct platform_device *scp_pdev; + struct clk *fd_clk; + struct rproc *rproc_handle; + + /* Lock for V4L2 operations */ + struct mutex vfd_lock; + + struct fd_user_output *output; + struct fd_buffer scp_mem; + void __iomem *fd_base; + void *rs_dma_buf; + dma_addr_t rs_dma_handle; + void *scp_mem_virt_addr; + + u32 fd_stream_count; + struct completion fd_job_finished; + struct delayed_work job_timeout_work; +}; + +struct mtk_fd_ctx { + struct mtk_fd_dev *fd_dev; + struct device *dev; + struct v4l2_fh fh; + struct v4l2_ctrl_handler hdl; + struct v4l2_pix_format_mplane src_fmt; + struct v4l2_meta_format dst_fmt; + struct user_param user_param; +}; + +#endif/*__MTK_FD_HW_H__*/ diff --git a/drivers/media/platform/mtk-isp/fd/mtk_fd_40.c b/drivers/media/platform/mtk-isp/fd/mtk_fd_40.c new file mode 100644 index 000000000000..4364232d7013 --- /dev/null +++ b/drivers/media/platform/mtk-isp/fd/mtk_fd_40.c @@ -0,0 +1,1279 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2018 MediaTek Inc. + * + * Author: Jerry-ch Chen + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mtk_fd.h" + +/* Set the face angle and directions to be detected */ +#define V4L2_CID_MTK_FD_DETECT_POSE (V4L2_CID_USER_MTK_FD_BASE + 1) + +/* Set image widths for an input image to be scaled down for face detection */ +#define V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH (V4L2_CID_USER_MTK_FD_BASE + 2) + +/* Set image heights for an input image to be scaled down for face detection */ +#define V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT (V4L2_CID_USER_MTK_FD_BASE + 3) + +/* Set the length of scale down size array */ +#define V4L2_CID_MTK_FD_SCALE_IMG_NUM (V4L2_CID_USER_MTK_FD_BASE + 4) + +/* Set the detection speed, usually reducing accuracy. */ +#define V4L2_CID_MTK_FD_DETECT_SPEED (V4L2_CID_USER_MTK_FD_BASE + 5) + +/* Select the detection model or algorithm to be used. */ +#define V4L2_CID_MTK_FD_DETECTION_MODEL (V4L2_CID_USER_MTK_FD_BASE + 6) + +/* We reserve 16 controls for this driver. */ +#define V4L2_CID_MTK_FD_MAX 16 + +static const struct v4l2_pix_format_mplane mtk_fd_img_fmts[] = { + { + .pixelformat = V4L2_PIX_FMT_VYUY, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_YUYV, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_YVYU, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_UYVY, + .num_planes = 1, + }, + { + .pixelformat = V4L2_PIX_FMT_NV16M, + .num_planes = 2, + }, + { + .pixelformat = V4L2_PIX_FMT_NV61M, + .num_planes = 2, + }, +}; + +#define NUM_FORMATS ARRAY_SIZE(mtk_fd_img_fmts) + +static inline struct mtk_fd_ctx *fh_to_ctx(struct v4l2_fh *fh) +{ + return container_of(fh, struct mtk_fd_ctx, fh); +} + +/* */ +static int mtk_fd_hw_alloc_rs_dma_addr(struct mtk_fd_dev *fd) +{ + struct device *dev = fd->dev; + void *va; + dma_addr_t dma_handle; + + va = dma_alloc_coherent(dev, MTK_FD_RS_BUF_SIZE, &dma_handle, + GFP_KERNEL); + if (!va) { + dev_err(dev, "dma_alloc null va\n"); + return -ENOMEM; + } + memset(va, 0, MTK_FD_RS_BUF_SIZE); + fd->rs_dma_buf = va; + fd->rs_dma_handle = dma_handle; + + return 0; +} + +static int mtk_fd_send_ipi_init(struct mtk_fd_dev *fd) +{ + struct ipi_message fd_init_msg; + + fd_init_msg.cmd_id = MTK_FD_IPI_CMD_INIT; + + fd_init_msg.fd_init_param.fd_manager.scp_addr = fd->scp_mem.scp_addr; + fd_init_msg.fd_init_param.fd_manager.dma_addr = fd->scp_mem.dma_addr; + + memset(fd->rs_dma_buf, 0, MTK_FD_RS_BUF_SIZE); + + fd_init_msg.fd_init_param.rs_dma_addr = fd->rs_dma_handle; + + return scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_init_msg, + sizeof(fd_init_msg), 300); +} + +static void mtk_fd_free_dma_handle(struct mtk_fd_dev *fd) +{ + dma_free_coherent(fd->dev, MTK_FD_RS_BUF_SIZE, + fd->rs_dma_buf, + fd->rs_dma_handle); +} + +static int mtk_fd_hw_enable(struct mtk_fd_dev *fd) +{ + int ret; + + pm_runtime_get_sync(fd->dev); + ret = mtk_fd_send_ipi_init(fd); + pm_runtime_put(fd->dev); + if (ret) { + dev_err(fd->dev, "Failed to send fd ipi init\n"); + return ret; + } + return 0; +} + +static void mtk_fd_hw_job_finish(struct mtk_fd_dev *fd, + enum vb2_buffer_state vb_state) +{ + struct mtk_fd_ctx *ctx; + struct vb2_v4l2_buffer *src_vbuf = NULL, *dst_vbuf = NULL; + + pm_runtime_put(fd->dev); + + ctx = v4l2_m2m_get_curr_priv(fd->m2m_dev); + src_vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + + v4l2_m2m_buf_copy_metadata(src_vbuf, dst_vbuf, + V4L2_BUF_FLAG_TSTAMP_SRC_MASK); + v4l2_m2m_buf_done(src_vbuf, vb_state); + v4l2_m2m_buf_done(dst_vbuf, vb_state); + v4l2_m2m_job_finish(fd->m2m_dev, ctx->fh.m2m_ctx); + complete_all(&fd->fd_job_finished); +} + +static void mtk_fd_hw_done(struct mtk_fd_dev *fd, + enum vb2_buffer_state vb_state) +{ + if (!cancel_delayed_work(&fd->job_timeout_work)) + return; + + mtk_fd_hw_job_finish(fd, vb_state); +} + +static void mtk_fd_ipi_handler(void *data, unsigned int len, void *priv) +{ + struct mtk_fd_dev *fd = (struct mtk_fd_dev *)priv; + struct device *dev = fd->dev; + struct ipi_message *fd_ack_msg = (struct ipi_message *)data; + struct fd_ack_param *fd_ack = &fd_ack_msg->fd_ack_param; + + dev_dbg(fd->dev, "fd_ipi_ack_id: %d\n", fd_ack_msg->cmd_id); + switch (fd_ack_msg->cmd_id) { + case MTK_FD_IPI_CMD_INIT_ACK: + return; + case MTK_FD_IPI_CMD_ENQ_ACK: + if (fd_ack->ret_code) { + dev_err(dev, "ipi ret: %d, message: %d\n", + fd_ack->ret_code, fd_ack->ret_msg); + mtk_fd_hw_done(fd, VB2_BUF_STATE_ERROR); + } + return; + case MTK_FD_IPI_CMD_EXIT_ACK: + if (fd_ack->ret_code) + dev_err(dev, "Failed to exit FD HW\n"); + return; + case MTK_FD_IPI_CMD_RESET_ACK: + if (fd_ack->ret_code) + dev_err(dev, "Failed to reset FD HW\n"); + return; + } +} + +static int mtk_fd_hw_connect(struct mtk_fd_dev *fd) +{ + int ret; + + ret = rproc_boot(fd->rproc_handle); + + if (ret < 0) { + /** + * Return 0 if downloading firmware successfully, + * otherwise it is failed + */ + dev_err(fd->dev, "Failed to boot rproc\n"); + return ret; + } + + ret = scp_ipi_register(fd->scp_pdev, SCP_IPI_FD_CMD, + mtk_fd_ipi_handler, fd); + if (ret) { + dev_err(fd->dev, "Failed to register IPI cmd handler\n"); + goto err_rproc_shutdown; + } + + fd->fd_stream_count++; + if (fd->fd_stream_count == 1) { + if (mtk_fd_hw_enable(fd)) { + ret = -EINVAL; + goto err_rproc_shutdown; + } + } + return 0; + +err_rproc_shutdown: + rproc_shutdown(fd->rproc_handle); + return ret; +} + +static void mtk_fd_exit_hw(struct mtk_fd_dev *fd) +{ + struct ipi_message fd_ipi_msg; + + fd_ipi_msg.cmd_id = MTK_FD_IPI_CMD_EXIT; + if (scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_ipi_msg, + sizeof(fd_ipi_msg), 300)) + dev_err(fd->dev, "FD EXIT HW error\n"); +} + +static void mtk_fd_hw_disconnect(struct mtk_fd_dev *fd) +{ + fd->fd_stream_count--; + mtk_fd_exit_hw(fd); + rproc_shutdown(fd->rproc_handle); +} + +static int mtk_fd_hw_job_exec(struct mtk_fd_dev *fd, + struct fd_enq_param *fd_param) +{ + struct ipi_message fd_ipi_msg; + int ret; + + pm_runtime_get_sync((fd->dev)); + + reinit_completion(&fd->fd_job_finished); + schedule_delayed_work(&fd->job_timeout_work, + msecs_to_jiffies(MTK_FD_HW_TIMEOUT)); + + fd_ipi_msg.cmd_id = MTK_FD_IPI_CMD_ENQUEUE; + memcpy(&fd_ipi_msg.fd_enq_param, fd_param, sizeof(struct fd_enq_param)); + ret = scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_ipi_msg, + sizeof(fd_ipi_msg), 300); + if (ret) { + mtk_fd_hw_done(fd, VB2_BUF_STATE_ERROR); + return ret; + } + return 0; +} + +static int mtk_fd_vb2_buf_out_validate(struct vb2_buffer *vb) +{ + struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb); + + if (v4l2_buf->field == V4L2_FIELD_ANY) + v4l2_buf->field = V4L2_FIELD_NONE; + if (v4l2_buf->field != V4L2_FIELD_NONE) + return -EINVAL; + + return 0; +} + +static int mtk_fd_vb2_buf_prepare(struct vb2_buffer *vb) +{ + struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); + struct vb2_queue *vq = vb->vb2_queue; + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + struct device *dev = ctx->dev; + struct v4l2_pix_format_mplane *pixfmt; + + switch (vq->type) { + case V4L2_BUF_TYPE_META_CAPTURE: + if (vb2_plane_size(vb, 0) < ctx->dst_fmt.buffersize) { + dev_dbg(dev, "meta size %lu is too small\n", + vb2_plane_size(vb, 0)); + return -EINVAL; + } + break; + case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + pixfmt = &ctx->src_fmt; + + if (vbuf->field == V4L2_FIELD_ANY) + vbuf->field = V4L2_FIELD_NONE; + + if (vb->num_planes > 2 || vbuf->field != V4L2_FIELD_NONE) { + dev_dbg(dev, "plane %d or field %d not supported\n", + vb->num_planes, vbuf->field); + return -EINVAL; + } + if (vb2_plane_size(vb, 0) < pixfmt->plane_fmt[0].sizeimage) { + dev_dbg(dev, "plane %lu is too small\n", + vb2_plane_size(vb, 0)); + return -EINVAL; + } + break; + } + + return 0; +} + +static void mtk_fd_vb2_buf_queue(struct vb2_buffer *vb) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); + + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); +} + +static int mtk_fd_vb2_queue_setup(struct vb2_queue *vq, + unsigned int *num_buffers, + unsigned int *num_planes, + unsigned int sizes[], + struct device *alloc_devs[]) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + unsigned int size[2]; + unsigned int plane; + + switch (vq->type) { + case V4L2_BUF_TYPE_META_CAPTURE: + size[0] = ctx->dst_fmt.buffersize; + break; + case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + size[0] = ctx->src_fmt.plane_fmt[0].sizeimage; + if (*num_planes == 2) + size[1] = ctx->src_fmt.plane_fmt[1].sizeimage; + break; + } + + if (*num_planes > 2) + return -EINVAL; + if (*num_planes == 0) { + if (vq->type == V4L2_BUF_TYPE_META_CAPTURE) { + sizes[0] = ctx->dst_fmt.buffersize; + *num_planes = 1; + return 0; + } + + *num_planes = ctx->src_fmt.num_planes; + for (plane = 0; plane < *num_planes; plane++) + sizes[plane] = ctx->src_fmt.plane_fmt[plane].sizeimage; + return 0; + } + + for (plane = 0; plane < *num_planes; plane++) { + if (sizes[plane] < size[plane]) + return -EINVAL; + } + return 0; +} + +static int mtk_fd_vb2_start_streaming(struct vb2_queue *vq, unsigned int count) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + + if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) + return mtk_fd_hw_connect(ctx->fd_dev); + else + return 0; +} + +static void mtk_fd_reset_hw(struct mtk_fd_dev *fd) +{ + struct ipi_message fd_ipi_msg; + + fd_ipi_msg.cmd_id = MTK_FD_IPI_CMD_RESET; + if (scp_ipi_send(fd->scp_pdev, SCP_IPI_FD_CMD, &fd_ipi_msg, + sizeof(fd_ipi_msg), 300)) + dev_err(fd->dev, "FD Reset HW error\n"); +} + +static void mtk_fd_job_timeout_work(struct work_struct *work) +{ + struct mtk_fd_dev *fd = + container_of(work, struct mtk_fd_dev, job_timeout_work.work); + + dev_err(fd->dev, "FD Job timeout!"); + mtk_fd_reset_hw(fd); + mtk_fd_hw_job_finish(fd, VB2_BUF_STATE_ERROR); +} + +static void mtk_fd_job_wait_finish(struct mtk_fd_dev *fd) +{ + wait_for_completion(&fd->fd_job_finished); +} + +static void mtk_fd_vb2_stop_streaming(struct vb2_queue *vq) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vq); + struct mtk_fd_dev *fd = ctx->fd_dev; + struct vb2_v4l2_buffer *vb; + struct v4l2_m2m_ctx *m2m_ctx = ctx->fh.m2m_ctx; + struct v4l2_m2m_queue_ctx *queue_ctx; + + mtk_fd_job_wait_finish(fd); + queue_ctx = V4L2_TYPE_IS_OUTPUT(vq->type) ? + &m2m_ctx->out_q_ctx : + &m2m_ctx->cap_q_ctx; + while ((vb = v4l2_m2m_buf_remove(queue_ctx))) + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); + + if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) + mtk_fd_hw_disconnect(fd); +} + +static void mtk_fd_vb2_request_complete(struct vb2_buffer *vb) +{ + struct mtk_fd_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + + v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->hdl); +} + +static int mtk_fd_querycap(struct file *file, void *fh, + struct v4l2_capability *cap) +{ + struct mtk_fd_dev *fd = video_drvdata(file); + struct device *dev = fd->dev; + + strscpy(cap->driver, dev_driver_string(dev), sizeof(cap->driver)); + strscpy(cap->card, dev_driver_string(dev), sizeof(cap->card)); + snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", + dev_name(fd->dev)); + + return 0; +} + +static int mtk_fd_enum_fmt_out_mp(struct file *file, void *fh, + struct v4l2_fmtdesc *f) +{ + if (f->index >= NUM_FORMATS) + return -EINVAL; + + f->pixelformat = mtk_fd_img_fmts[f->index].pixelformat; + return 0; +} + +static void mtk_fd_fill_pixfmt_mp(struct v4l2_pix_format_mplane *dfmt, + const struct v4l2_pix_format_mplane *sfmt) +{ + dfmt->field = V4L2_FIELD_NONE; + dfmt->colorspace = V4L2_COLORSPACE_BT2020; + dfmt->num_planes = sfmt->num_planes; + dfmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; + dfmt->quantization = V4L2_QUANTIZATION_DEFAULT; + dfmt->xfer_func = + V4L2_MAP_XFER_FUNC_DEFAULT(dfmt->colorspace); + + /* Keep user setting as possible */ + dfmt->width = clamp(dfmt->width, + MTK_FD_OUTPUT_MIN_WIDTH, + MTK_FD_OUTPUT_MAX_WIDTH); + dfmt->height = clamp(dfmt->height, + MTK_FD_OUTPUT_MIN_HEIGHT, + MTK_FD_OUTPUT_MAX_HEIGHT); + + if (sfmt->num_planes == 2) { + /* NV16M and NV61M has 1 byte per pixel */ + dfmt->plane_fmt[0].bytesperline = dfmt->width; + dfmt->plane_fmt[1].bytesperline = dfmt->width; + } else { + /* 2 bytes per pixel */ + dfmt->plane_fmt[0].bytesperline = dfmt->width * 2; + } + + dfmt->plane_fmt[0].sizeimage = + dfmt->height * dfmt->plane_fmt[0].bytesperline; +} + +static const struct v4l2_pix_format_mplane *mtk_fd_find_fmt(u32 format) +{ + unsigned int i; + const struct v4l2_pix_format_mplane *dev_fmt; + + for (i = 0; i < NUM_FORMATS; i++) { + dev_fmt = &mtk_fd_img_fmts[i]; + if (dev_fmt->pixelformat == format) + return dev_fmt; + } + + return NULL; +} + +static int mtk_fd_try_fmt_out_mp(struct file *file, + void *fh, + struct v4l2_format *f) +{ + struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; + const struct v4l2_pix_format_mplane *fmt; + + fmt = mtk_fd_find_fmt(pix_mp->pixelformat); + if (!fmt) + fmt = &mtk_fd_img_fmts[0]; /* Get default img fmt */ + + mtk_fd_fill_pixfmt_mp(pix_mp, fmt); + return 0; +} + +static int mtk_fd_g_fmt_out_mp(struct file *file, void *fh, + struct v4l2_format *f) +{ + struct mtk_fd_ctx *ctx = fh_to_ctx(fh); + + f->fmt.pix_mp = ctx->src_fmt; + + return 0; +} + +static int mtk_fd_s_fmt_out_mp(struct file *file, void *fh, + struct v4l2_format *f) +{ + struct mtk_fd_ctx *ctx = fh_to_ctx(fh); + struct vb2_queue *vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); + + /* Change not allowed if queue is streaming. */ + if (vb2_is_streaming(vq)) { + dev_err(ctx->dev, "Failed to set format, vb2 is busy\n"); + return -EBUSY; + } + + mtk_fd_try_fmt_out_mp(file, fh, f); + ctx->src_fmt = f->fmt.pix_mp; + + return 0; +} + +static int mtk_fd_enum_fmt_meta_cap(struct file *file, void *fh, + struct v4l2_fmtdesc *f) +{ + if (f->index) + return -EINVAL; + + strscpy(f->description, "Face detection result", + sizeof(f->description)); + f->pixelformat = V4L2_META_FMT_MTFD_RESULT; + f->flags = 0; + + return 0; +} + +static int mtk_fd_g_fmt_meta_cap(struct file *file, void *fh, + struct v4l2_format *f) +{ + f->fmt.meta.dataformat = V4L2_META_FMT_MTFD_RESULT; + f->fmt.meta.buffersize = sizeof(struct fd_user_output); + + return 0; +} + +static const struct vb2_ops mtk_fd_vb2_ops = { + .queue_setup = mtk_fd_vb2_queue_setup, + .buf_out_validate = mtk_fd_vb2_buf_out_validate, + .buf_prepare = mtk_fd_vb2_buf_prepare, + .buf_queue = mtk_fd_vb2_buf_queue, + .start_streaming = mtk_fd_vb2_start_streaming, + .stop_streaming = mtk_fd_vb2_stop_streaming, + .wait_prepare = vb2_ops_wait_prepare, + .wait_finish = vb2_ops_wait_finish, + .buf_request_complete = mtk_fd_vb2_request_complete, +}; + +static const struct v4l2_ioctl_ops mtk_fd_v4l2_video_out_ioctl_ops = { + .vidioc_querycap = mtk_fd_querycap, + .vidioc_enum_fmt_vid_out = mtk_fd_enum_fmt_out_mp, + .vidioc_g_fmt_vid_out_mplane = mtk_fd_g_fmt_out_mp, + .vidioc_s_fmt_vid_out_mplane = mtk_fd_s_fmt_out_mp, + .vidioc_try_fmt_vid_out_mplane = mtk_fd_try_fmt_out_mp, + .vidioc_enum_fmt_meta_cap = mtk_fd_enum_fmt_meta_cap, + .vidioc_g_fmt_meta_cap = mtk_fd_g_fmt_meta_cap, + .vidioc_s_fmt_meta_cap = mtk_fd_g_fmt_meta_cap, + .vidioc_try_fmt_meta_cap = mtk_fd_g_fmt_meta_cap, + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, + .vidioc_streamon = v4l2_m2m_ioctl_streamon, + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, + .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, +}; + +static int +mtk_fd_queue_init(void *priv, struct vb2_queue *src_vq, + struct vb2_queue *dst_vq) +{ + struct mtk_fd_ctx *ctx = priv; + int ret; + + src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; + src_vq->io_modes = VB2_MMAP | VB2_DMABUF; + src_vq->supports_requests = true; + src_vq->drv_priv = ctx; + src_vq->ops = &mtk_fd_vb2_ops; + src_vq->mem_ops = &vb2_dma_contig_memops; + src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + src_vq->lock = &ctx->fd_dev->vfd_lock; + src_vq->dev = ctx->fd_dev->v4l2_dev.dev; + + ret = vb2_queue_init(src_vq); + if (ret) + return ret; + + dst_vq->type = V4L2_BUF_TYPE_META_CAPTURE; + dst_vq->io_modes = VB2_MMAP | VB2_DMABUF; + dst_vq->drv_priv = ctx; + dst_vq->ops = &mtk_fd_vb2_ops; + dst_vq->mem_ops = &vb2_dma_contig_memops; + dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + dst_vq->lock = &ctx->fd_dev->vfd_lock; + dst_vq->dev = ctx->fd_dev->v4l2_dev.dev; + + return vb2_queue_init(dst_vq); +} + +static struct v4l2_ctrl_config mtk_fd_controls[] = { + { + .id = V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH, + .name = "FD scale image widths", + .type = V4L2_CTRL_TYPE_U16, + .min = MTK_FD_OUTPUT_MIN_WIDTH, + .max = MTK_FD_OUTPUT_MAX_WIDTH, + .step = 1, + .def = MTK_FD_OUTPUT_MAX_WIDTH, + .dims = { MTK_FD_SCALE_ARR_NUM }, + }, + { + .id = V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT, + .name = "FD scale image heights", + .type = V4L2_CTRL_TYPE_U16, + .min = MTK_FD_OUTPUT_MIN_HEIGHT, + .max = MTK_FD_OUTPUT_MAX_HEIGHT, + .step = 1, + .def = MTK_FD_OUTPUT_MAX_HEIGHT, + .dims = { MTK_FD_SCALE_ARR_NUM }, + }, + { + .id = V4L2_CID_MTK_FD_SCALE_IMG_NUM, + .name = "FD scale size counts", + .type = V4L2_CTRL_TYPE_INTEGER, + .min = 0, + .max = MTK_FD_SCALE_ARR_NUM, + .step = 1, + .def = 0, + }, + { + .id = V4L2_CID_MTK_FD_DETECT_POSE, + .name = "FD detect face angle and directions", + .type = V4L2_CTRL_TYPE_U16, + .min = 0, + .max = 0xffff, + .step = 1, + .def = 0x3ff, + .dims = { MTK_FD_FACE_ANGLE_NUM}, + }, + { + .id = V4L2_CID_MTK_FD_DETECT_SPEED, + .name = "FD detection speedup", + .type = V4L2_CTRL_TYPE_INTEGER, + .min = 0, + .max = MTK_FD_MAX_SPEEDUP, + .step = 1, + .def = 0, + }, + { + .id = V4L2_CID_MTK_FD_DETECTION_MODEL, + .name = "FD use extra model", + .type = V4L2_CTRL_TYPE_BOOLEAN, + .min = 0, + .max = 1, + .step = 1, + .def = 0, + }, +}; + +static int mtk_fd_ctrls_setup(struct mtk_fd_ctx *ctx) +{ + struct v4l2_ctrl_handler *hdl = &ctx->hdl; + int i; + + v4l2_ctrl_handler_init(hdl, V4L2_CID_MTK_FD_MAX); + if (hdl->error) + return hdl->error; + + for (i = 0; i < ARRAY_SIZE(mtk_fd_controls); i++) { + v4l2_ctrl_new_custom(hdl, &mtk_fd_controls[i], ctx); + if (hdl->error) { + v4l2_ctrl_handler_free(hdl); + dev_err(ctx->dev, "Failed to register controls:%d", i); + return hdl->error; + } + } + + ctx->fh.ctrl_handler = &ctx->hdl; + v4l2_ctrl_handler_setup(hdl); + + return 0; +} + +static unsigned int get_fd_img_fmt(unsigned int fourcc) +{ + switch (fourcc) { + case V4L2_PIX_FMT_VYUY: + return MTK_FD_HW_FMT_VYUY; + case V4L2_PIX_FMT_YUYV: + return MTK_FD_HW_FMT_YUYV; + case V4L2_PIX_FMT_YVYU: + return MTK_FD_HW_FMT_YVYU; + case V4L2_PIX_FMT_UYVY: + return MTK_FD_HW_FMT_UYVY; + case V4L2_PIX_FMT_NV16M: + return MTK_FD_HW_FMT_YUV_2P; + case V4L2_PIX_FMT_NV61M: + return MTK_FD_HW_FMT_YVU_2P; + default: + return MTK_FD_HW_FMT_UNKNOWN; + } +} + +static void init_ctx_fmt(struct mtk_fd_ctx *ctx) +{ + struct v4l2_pix_format_mplane *src_fmt = &ctx->src_fmt; + struct v4l2_meta_format *dst_fmt = &ctx->dst_fmt; + + /* Initialize M2M source fmt */ + src_fmt->width = MTK_FD_OUTPUT_MAX_WIDTH; + src_fmt->height = MTK_FD_OUTPUT_MAX_HEIGHT; + mtk_fd_fill_pixfmt_mp(src_fmt, &mtk_fd_img_fmts[0]); + + /* Initialize M2M destination fmt */ + dst_fmt->buffersize = sizeof(struct fd_user_output); + dst_fmt->dataformat = V4L2_META_FMT_MTFD_RESULT; +} + +/* + * V4L2 file operations. + */ +static int mtk_vfd_open(struct file *filp) +{ + struct mtk_fd_dev *fd = video_drvdata(filp); + struct video_device *vdev = video_devdata(filp); + struct mtk_fd_ctx *ctx; + int ret; + + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + ctx->fd_dev = fd; + ctx->dev = fd->dev; + fd->ctx = ctx; + + v4l2_fh_init(&ctx->fh, vdev); + filp->private_data = &ctx->fh; + + init_ctx_fmt(ctx); + + ret = mtk_fd_ctrls_setup(ctx); + if (ret) { + dev_err(ctx->dev, "Failed to set up controls:%d\n", ret); + goto err_fh_exit; + } + + ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(fd->m2m_dev, ctx, + &mtk_fd_queue_init); + if (IS_ERR(ctx->fh.m2m_ctx)) { + ret = PTR_ERR(ctx->fh.m2m_ctx); + goto err_free_ctrl_handler; + } + + v4l2_fh_add(&ctx->fh); + + return 0; + +err_free_ctrl_handler: + v4l2_ctrl_handler_free(&ctx->hdl); +err_fh_exit: + v4l2_fh_exit(&ctx->fh); + kfree(ctx); + + return ret; +} + +static int mtk_vfd_release(struct file *filp) +{ + struct mtk_fd_ctx *ctx = container_of(filp->private_data, + struct mtk_fd_ctx, fh); + + v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); + + v4l2_ctrl_handler_free(&ctx->hdl); + v4l2_fh_del(&ctx->fh); + v4l2_fh_exit(&ctx->fh); + + kfree(ctx); + + return 0; +} + +static const struct v4l2_file_operations fd_video_fops = { + .owner = THIS_MODULE, + .open = mtk_vfd_open, + .release = mtk_vfd_release, + .poll = v4l2_m2m_fop_poll, + .unlocked_ioctl = video_ioctl2, + .mmap = v4l2_m2m_fop_mmap, +#ifdef CONFIG_COMPAT + .compat_ioctl32 = v4l2_compat_ioctl32, +#endif + +}; + +static void mtk_fd_fill_user_param(struct user_param *user_param, + struct v4l2_ctrl_handler *hdl) +{ + struct v4l2_ctrl *ctrl; + int i; + + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH); + if (ctrl) + for (i = 0; i < ctrl->elems; i++) + user_param->scale_img_width[i] = ctrl->p_new.p_u16[i]; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT); + if (ctrl) + for (i = 0; i < ctrl->elems; i++) + user_param->scale_img_height[i] = ctrl->p_new.p_u16[i]; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_SCALE_IMG_NUM); + if (ctrl) + user_param->scale_img_num = ctrl->val; + + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_DETECT_POSE); + if (ctrl) + for (i = 0; i < ctrl->elems; i++) + user_param->face_directions[i] = ctrl->p_new.p_u16[i]; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_DETECT_SPEED); + if (ctrl) + user_param->fd_speedup = ctrl->val; + ctrl = v4l2_ctrl_find(hdl, V4L2_CID_MTK_FD_DETECTION_MODEL); + if (ctrl) + user_param->fd_extra_model = ctrl->val; +} + +static void mtk_fd_device_run(void *priv) +{ + struct mtk_fd_ctx *ctx = priv; + struct mtk_fd_dev *fd = ctx->fd_dev; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + struct fd_enq_param fd_param; + void *plane_vaddr; + + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); + + fd_param.src_img[0].dma_addr = + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0); + fd_param.user_result.dma_addr = + vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0); + plane_vaddr = vb2_plane_vaddr(&dst_buf->vb2_buf, 0); + fd_param.output_vaddr = (u64)(unsigned long)plane_vaddr; + fd_param.user_param.src_img_fmt = + get_fd_img_fmt(ctx->src_fmt.pixelformat); + if (ctx->src_fmt.num_planes == 2) + fd_param.src_img[1].dma_addr = + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 1); + mtk_fd_fill_user_param(&fd_param.user_param, &ctx->hdl); + + /* Complete request controls if any */ + v4l2_ctrl_request_complete(src_buf->vb2_buf.req_obj.req, &ctx->hdl); + + fd->output = plane_vaddr; + mtk_fd_hw_job_exec(fd, &fd_param); +} + +static struct v4l2_m2m_ops fd_m2m_ops = { + .device_run = mtk_fd_device_run, +}; + +static const struct media_device_ops fd_m2m_media_ops = { + .req_validate = vb2_request_validate, + .req_queue = v4l2_m2m_request_queue, +}; + +static int mtk_fd_video_device_register(struct mtk_fd_dev *fd) +{ + struct video_device *vfd = &fd->vfd; + struct v4l2_m2m_dev *m2m_dev = fd->m2m_dev; + struct device *dev = fd->dev; + int ret; + + vfd->fops = &fd_video_fops; + vfd->release = video_device_release; + vfd->lock = &fd->vfd_lock; + vfd->v4l2_dev = &fd->v4l2_dev; + vfd->vfl_dir = VFL_DIR_M2M; + vfd->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT_MPLANE | + V4L2_CAP_META_CAPTURE; + vfd->ioctl_ops = &mtk_fd_v4l2_video_out_ioctl_ops; + + strscpy(vfd->name, dev_driver_string(dev), sizeof(vfd->name)); + + video_set_drvdata(vfd, fd); + + ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0); + if (ret) { + dev_err(dev, "Failed to register video device\n"); + goto err_free_dev; + } + + ret = v4l2_m2m_register_media_controller(m2m_dev, vfd, + MEDIA_ENT_F_PROC_VIDEO_STATISTICS); + if (ret) { + dev_err(dev, "Failed to init mem2mem media controller\n"); + goto err_unreg_video; + } + return 0; + +err_unreg_video: + video_unregister_device(vfd); +err_free_dev: + video_device_release(vfd); + return ret; +} + +static int mtk_fd_dev_v4l2_init(struct mtk_fd_dev *fd) +{ + struct media_device *mdev = &fd->mdev; + struct device *dev = fd->dev; + int ret; + + ret = v4l2_device_register(dev, &fd->v4l2_dev); + if (ret) { + dev_err(dev, "Failed to register v4l2 device\n"); + return ret; + } + + fd->m2m_dev = v4l2_m2m_init(&fd_m2m_ops); + if (IS_ERR(fd->m2m_dev)) { + dev_err(dev, "Failed to init mem2mem device\n"); + ret = PTR_ERR(fd->m2m_dev); + goto err_unreg_v4l2_dev; + } + + mdev->dev = dev; + strscpy(mdev->model, dev_driver_string(dev), sizeof(mdev->model)); + snprintf(mdev->bus_info, sizeof(mdev->bus_info), + "platform:%s", dev_name(dev)); + media_device_init(mdev); + mdev->ops = &fd_m2m_media_ops; + fd->v4l2_dev.mdev = mdev; + + ret = mtk_fd_video_device_register(fd); + if (ret) { + dev_err(dev, "Failed to register video device\n"); + goto err_cleanup_mdev; + } + + ret = media_device_register(mdev); + if (ret) { + dev_err(dev, "Failed to register mem2mem media device\n"); + goto err_unreg_vdev; + } + + return 0; + +err_unreg_vdev: + v4l2_m2m_unregister_media_controller(fd->m2m_dev); + video_unregister_device(&fd->vfd); + video_device_release(&fd->vfd); +err_cleanup_mdev: + media_device_cleanup(mdev); + v4l2_m2m_release(fd->m2m_dev); +err_unreg_v4l2_dev: + v4l2_device_unregister(&fd->v4l2_dev); + return ret; +} + +static void mtk_fd_dev_v4l2_release(struct mtk_fd_dev *fd) +{ + v4l2_m2m_unregister_media_controller(fd->m2m_dev); + video_unregister_device(&fd->vfd); + video_device_release(&fd->vfd); + media_device_cleanup(&fd->mdev); + v4l2_m2m_release(fd->m2m_dev); + v4l2_device_unregister(&fd->v4l2_dev); +} + +static irqreturn_t mtk_fd_irq(int irq, void *data) +{ + struct mtk_fd_dev *fd = (struct mtk_fd_dev *)data; + + /* must read this register otherwise HW will keep sending irq */ + readl(fd->fd_base + MTK_FD_REG_OFFSET_INT_VAL); + fd->output->number = readl(fd->fd_base + MTK_FD_REG_OFFSET_RESULT); + dev_dbg(fd->dev, "mtk_fd_face_num:%d\n", fd->output->number); + + mtk_fd_hw_done(fd, VB2_BUF_STATE_DONE); + return IRQ_HANDLED; +} + +static int mtk_fd_hw_get_scp_mem(struct mtk_fd_dev *fd) +{ + struct device *dev = fd->dev; + dma_addr_t addr; + void *ptr; + u32 ret; + + /* + * Allocate coherent reserved memory for SCP firmware usage. + * The size of SCP composer's memory is fixed to 0x100000 + * for the requirement of firmware. + */ + ptr = dma_alloc_coherent(&fd->scp_pdev->dev, + MTK_FD_HW_WORK_BUF_SIZE, &addr, GFP_KERNEL); + if (!ptr) + return -ENOMEM; + + fd->scp_mem.scp_addr = addr; + fd->scp_mem_virt_addr = ptr; + dev_info(dev, "scp addr:%pad va:%pK\n", &addr, ptr); + + /* + * This reserved memory is also be used by FD HW. + * Need to get iova address for FD DMA. + */ + addr = dma_map_resource(dev, addr, MTK_FD_HW_WORK_BUF_SIZE, + DMA_TO_DEVICE, DMA_ATTR_SKIP_CPU_SYNC); + if (dma_mapping_error(dev, addr)) { + dev_err(dev, "Failed to map scp iova\n"); + ret = -ENOMEM; + goto fail_free_mem; + } + fd->scp_mem.dma_addr = addr; + dev_info(dev, "scp iova addr:%pad\n", &addr); + + return 0; + +fail_free_mem: + dma_free_coherent(&fd->scp_pdev->dev, MTK_FD_HW_WORK_BUF_SIZE, + ptr, fd->scp_mem.scp_addr); + fd->scp_mem.scp_addr = 0; + + return ret; +} + +static int mtk_fd_probe(struct platform_device *pdev) +{ + struct mtk_fd_dev *fd; + struct device *dev = &pdev->dev; + + struct resource *res; + phandle rproc_phandle; + int irq; + int ret; + + fd = devm_kzalloc(&pdev->dev, sizeof(*fd), GFP_KERNEL); + if (!fd) + return -ENOMEM; + + dev_set_drvdata(dev, fd); + fd->dev = dev; + + irq = platform_get_irq(pdev, 0); + if (irq < 0) { + dev_err(dev, "Failed to get irq by platform: %d\n", irq); + return irq; + } + ret = devm_request_irq(dev, irq, mtk_fd_irq, IRQF_SHARED, + dev_driver_string(dev), + fd); + if (ret) { + dev_err(dev, "Failed to request irq\n"); + return ret; + } + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + fd->fd_base = devm_ioremap_resource(dev, res); + if (IS_ERR(fd->fd_base)) { + dev_err(dev, "Failed to get fd reg base\n"); + return PTR_ERR(fd->fd_base); + } + + fd->fd_clk = devm_clk_get(dev, "fd"); + if (IS_ERR(fd->fd_clk)) { + dev_err(dev, "Failed to get fd_clk_img_fd clock\n"); + return PTR_ERR(fd->fd_clk); + } + + /* init scp */ + fd->scp_pdev = scp_get_pdev(pdev); + if (!fd->scp_pdev) { + dev_err(dev, "Failed to get scp device\n"); + return -ENODEV; + } + + if (of_property_read_u32(fd->dev->of_node, "mediatek,scp", + &rproc_phandle)) { + dev_err(dev, "Failed to get scp device\n"); + return -EINVAL; + } + + fd->rproc_handle = rproc_get_by_phandle(rproc_phandle); + if (!fd->rproc_handle) { + dev_err(dev, "Failed to get FD's rproc_handle\n"); + return -EINVAL; + } + + ret = mtk_fd_hw_get_scp_mem(fd); + if (ret) { + dev_err(dev, "Failed to init scp memory: %d\n", ret); + return ret; + } + + ret = mtk_fd_hw_alloc_rs_dma_addr(fd); + if (ret) { + dev_err(dev, "Failed to allocate dma buffer: %d\n", ret); + return ret; + } + + mutex_init(&fd->vfd_lock); + init_completion(&fd->fd_job_finished); + INIT_DELAYED_WORK(&fd->job_timeout_work, mtk_fd_job_timeout_work); + pm_runtime_enable(dev); + + ret = mtk_fd_dev_v4l2_init(fd); + if (ret) { + dev_err(dev, "Failed to init v4l2 device: %d\n", ret); + goto err_destroy_mutex; + } + + return 0; + +err_destroy_mutex: + mutex_destroy(&fd->vfd_lock); + pm_runtime_disable(fd->dev); + mtk_fd_free_dma_handle(fd); + return ret; +} + +static int mtk_fd_remove(struct platform_device *pdev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(&pdev->dev); + + mtk_fd_dev_v4l2_release(fd); + pm_runtime_disable(&pdev->dev); + dma_unmap_page_attrs(fd->dev, + fd->scp_mem.dma_addr, + MTK_FD_HW_WORK_BUF_SIZE, + DMA_TO_DEVICE, + DMA_ATTR_SKIP_CPU_SYNC); + dma_free_coherent(&fd->scp_pdev->dev, + MTK_FD_HW_WORK_BUF_SIZE, + fd->scp_mem_virt_addr, + fd->scp_mem.scp_addr); + mutex_destroy(&fd->vfd_lock); + mtk_fd_free_dma_handle(fd); + rproc_put(fd->rproc_handle); + + return 0; +} + +static int mtk_fd_suspend(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + + if (pm_runtime_suspended(dev)) + return 0; + + v4l2_m2m_suspend(fd->m2m_dev); + + /* suspend FD HW */ + writel(0x0, fd->fd_base + MTK_FD_REG_OFFSET_INT_EN); + writel(0x0, fd->fd_base + MTK_FD_REG_OFFSET_HW_ENABLE); + clk_disable_unprepare(fd->fd_clk); + dev_dbg(dev, "%s:disable clock\n", __func__); + + return 0; +} + +static int mtk_fd_resume(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + int ret; + + if (pm_runtime_suspended(dev)) + return 0; + + ret = clk_prepare_enable(fd->fd_clk); + if (ret < 0) { + dev_dbg(dev, "Failed to open fd clk:%d\n", ret); + return ret; + } + + /* resume FD HW */ + writel(MTK_FD_SET_HW_ENABLE, fd->fd_base + MTK_FD_REG_OFFSET_HW_ENABLE); + writel(0x1, fd->fd_base + MTK_FD_REG_OFFSET_INT_EN); + dev_dbg(dev, "%s:enable clock\n", __func__); + + v4l2_m2m_resume(fd->m2m_dev); + + return 0; +} + +static int mtk_fd_runtime_suspend(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + + clk_disable_unprepare(fd->fd_clk); + return 0; +} + +static int mtk_fd_runtime_resume(struct device *dev) +{ + struct mtk_fd_dev *fd = dev_get_drvdata(dev); + int ret; + + ret = clk_prepare_enable(fd->fd_clk); + if (ret < 0) { + dev_err(dev, "Failed to open fd clk:%d\n", ret); + return ret; + } + + return 0; +} + +static const struct dev_pm_ops mtk_fd_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(mtk_fd_suspend, mtk_fd_resume) + SET_RUNTIME_PM_OPS(mtk_fd_runtime_suspend, mtk_fd_runtime_resume, NULL) +}; + +static const struct of_device_id mtk_fd_of_ids[] = { + { .compatible = "mediatek,mt8183-fd", }, + {} +}; +MODULE_DEVICE_TABLE(of, mtk_fd_of_ids); + +static struct platform_driver mtk_fd_driver = { + .probe = mtk_fd_probe, + .remove = mtk_fd_remove, + .driver = { + .name = "mtk-fd-4.0", + .of_match_table = of_match_ptr(mtk_fd_of_ids), + .pm = &mtk_fd_pm_ops, + } +}; +module_platform_driver(mtk_fd_driver); +MODULE_AUTHOR("Jerry-ch Chen "); +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("Mediatek FD driver"); diff --git a/include/uapi/linux/v4l2-controls.h b/include/uapi/linux/v4l2-controls.h index 3dcfc6148f99..eae876ea6d0a 100644 --- a/include/uapi/linux/v4l2-controls.h +++ b/include/uapi/linux/v4l2-controls.h @@ -192,6 +192,10 @@ enum v4l2_colorfx { * We reserve 16 controls for this driver. */ #define V4L2_CID_USER_IMX_BASE (V4L2_CID_USER_BASE + 0x10b0) +/* The base for the mediatek FD driver controls */ +/* We reserve 16 controls for this driver. */ +#define V4L2_CID_USER_MTK_FD_BASE (V4L2_CID_USER_BASE + 0x10d0) + /* MPEG-class control IDs */ /* The MPEG controls are applicable to all codec controls * and the 'MPEG' part of the define is historical */ diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h index b5671ce2724f..203e49ebc9e8 100644 --- a/include/uapi/linux/videodev2.h +++ b/include/uapi/linux/videodev2.h @@ -721,6 +721,9 @@ struct v4l2_pix_format { #define V4L2_META_FMT_UVC v4l2_fourcc('U', 'V', 'C', 'H') /* UVC Payload Header metadata */ #define V4L2_META_FMT_D4XX v4l2_fourcc('D', '4', 'X', 'X') /* D4XX Payload Header metadata */ +/* Vendor specific - Mediatek Face Detection meta buffer format for firmware */ +#define V4L2_META_FMT_MTFD_RESULT v4l2_fourcc('M', 'T', 'f', 'd') /* FD meta capture buffer */ + /* priv field value to indicates that subsequent fields are valid. */ #define V4L2_PIX_FMT_PRIV_MAGIC 0xfeedcafe -- 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=-9.8 required=3.0 tests=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, 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 35B74C43603 for ; Wed, 4 Dec 2019 12:48:07 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C840A2077B for ; Wed, 4 Dec 2019 12:48:06 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="fCWd/G8e" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727726AbfLDMsG (ORCPT ); Wed, 4 Dec 2019 07:48:06 -0500 Received: from mailgw01.mediatek.com ([210.61.82.183]:51539 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726832AbfLDMsG (ORCPT ); Wed, 4 Dec 2019 07:48:06 -0500 X-UUID: 3ad60449e39b426bbfc526b0e1756b64-20191204 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=zochh5N1EFTk7uzD+0ZuSDkeQLR4Al9dvt6pqNoHDGY=; b=fCWd/G8e1nxz2UJAcYorSfWbYy8W6wKzSvs6FXMlltEMUH78j2WFzTTMn9m5fvuAc3mVfiCfhrgq22No3aznXl0pJ75NFWxLZ920BVtgyVEZdP70mAxWMcZbra3bl8xxXoD4RR+P2jN2/YfCKOa++AqA0oMZgWgf8YID/K9rWUU=; X-UUID: 3ad60449e39b426bbfc526b0e1756b64-20191204 Received: from mtkcas09.mediatek.inc [(172.21.101.178)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 1377361347; Wed, 04 Dec 2019 20:47:49 +0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Dec 2019 20:47:48 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Dec 2019 20:46:53 +0800 From: Jerry-ch Chen To: , , , , CC: , , , , , , , , , , , , , , , Jerry-ch Chen Subject: [RFC PATCH V4 4/4] platform: mtk-isp: Add Mediatek FD driver Date: Wed, 4 Dec 2019 20:47:32 +0800 Message-ID: <20191204124732.10932-5-Jerry-Ch.chen@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20191204124732.10932-1-Jerry-Ch.chen@mediatek.com> References: <20191204124732.10932-1-Jerry-Ch.chen@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-TM-SNTS-SMTP: B9A59B929813E828148439615B4C3099B26B454A7EAC0E23C2B41F7CB347283E2000:8 X-MTK: N Content-Transfer-Encoding: base64 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org RnJvbTogSmVycnktY2ggQ2hlbiA8amVycnktY2guY2hlbkBtZWRpYXRlay5jb20+DQoNClRoaXMg cGF0Y2ggYWRkcyB0aGUgZHJpdmVyIG9mIEZhY2UgRGV0ZWN0aW9uIChGRCkgdW5pdCBpbg0KTWVk aWF0ZWsgY2FtZXJhIHN5c3RlbSwgcHJvdmlkaW5nIGZhY2UgZGV0ZWN0aW9uIGZ1bmN0aW9uLg0K DQpUaGUgbXRrLWlzcCBkaXJlY3Rvcnkgd2lsbCBjb250YWluIGRyaXZlcnMgZm9yIG11bHRpcGxl IElQDQpibG9ja3MgZm91bmQgaW4gTWVkaWF0ZWsgSVNQIHN5c3RlbS4gSXQgd2lsbCBpbmNsdWRl IElTUCBQYXNzIDENCmRyaXZlciAoQ0FNKSwgc2Vuc29yIGludGVyZmFjZSBkcml2ZXIsIERJUCBk cml2ZXIgYW5kIGZhY2UNCmRldGVjdGlvbiBkcml2ZXIuDQoNClNpZ25lZC1vZmYtYnk6IEplcnJ5 LWNoIENoZW4gPGplcnJ5LWNoLmNoZW5AbWVkaWF0ZWsuY29tPg0KLS0tDQogZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9LY29uZmlnICAgICAgICAgICAgICAgIHwgICAgMiArDQogZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9NYWtlZmlsZSAgICAgICAgICAgICAgIHwgICAgMiArDQogZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9tdGstaXNwL2ZkL0tjb25maWcgICAgIHwgICAxOSArDQogZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9tdGstaXNwL2ZkL01ha2VmaWxlICAgIHwgICAgNSArDQogZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9tdGstaXNwL2ZkL210a19mZC5oICAgIHwgIDE0OSArKw0KIGRyaXZlcnMvbWVk aWEvcGxhdGZvcm0vbXRrLWlzcC9mZC9tdGtfZmRfNDAuYyB8IDEyNzkgKysrKysrKysrKysrKysr KysNCiBpbmNsdWRlL3VhcGkvbGludXgvdjRsMi1jb250cm9scy5oICAgICAgICAgICAgfCAgICA0 ICsNCiBpbmNsdWRlL3VhcGkvbGludXgvdmlkZW9kZXYyLmggICAgICAgICAgICAgICAgfCAgICAz ICsNCiA4IGZpbGVzIGNoYW5nZWQsIDE0NjMgaW5zZXJ0aW9ucygrKQ0KIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvS2NvbmZpZw0KIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvTWFrZWZpbGUNCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstaXNwL2ZkL210a19m ZC5oDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWlzcC9m ZC9tdGtfZmRfNDAuYw0KDQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9LY29u ZmlnIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9LY29uZmlnDQppbmRleCBhNTA1ZTlmNWExZTIu LmFlOTkyNThlMjZhNSAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vS2NvbmZp Zw0KKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9LY29uZmlnDQpAQCAtMzIsNiArMzIsOCBA QCBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vZGF2aW5jaS9LY29uZmlnIg0KIA0KIHNv dXJjZSAiZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9vbWFwL0tjb25maWciDQogDQorc291cmNlICJk cml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvS2NvbmZpZyINCisNCiBjb25maWcgVklE RU9fQVNQRUVEDQogCXRyaXN0YXRlICJBc3BlZWQgQVNUMjQwMCBhbmQgQVNUMjUwMCBWaWRlbyBF bmdpbmUgZHJpdmVyIg0KIAlkZXBlbmRzIG9uIFZJREVPX1Y0TDINCmRpZmYgLS1naXQgYS9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL01ha2VmaWxlIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9NYWtl ZmlsZQ0KaW5kZXggZTZkZWIyNTk3NzM4Li44YjgxN2NjODBmNDMgMTAwNjQ0DQotLS0gYS9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL01ha2VmaWxlDQorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3Jt L01ha2VmaWxlDQpAQCAtOTQsNiArOTQsOCBAQCBvYmotJChDT05GSUdfVklERU9fTUVESUFURUtf TURQKQkrPSBtdGstbWRwLw0KIA0KIG9iai0kKENPTkZJR19WSURFT19NRURJQVRFS19KUEVHKQkr PSBtdGstanBlZy8NCiANCitvYmotJChDT05GSUdfVklERU9fTUVESUFURUtfRkQpCQkrPSBtdGst aXNwL2ZkLw0KKw0KIG9iai0kKENPTkZJR19WSURFT19RQ09NX0NBTVNTKQkJKz0gcWNvbS9jYW1z cy8NCiANCiBvYmotJChDT05GSUdfVklERU9fUUNPTV9WRU5VUykJCSs9IHFjb20vdmVudXMvDQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstaXNwL2ZkL0tjb25maWcgYi9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvS2NvbmZpZw0KbmV3IGZpbGUgbW9kZSAx MDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4uN2E3NDdkOTQ3ZTg4DQotLS0gL2Rldi9udWxsDQor KysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvS2NvbmZpZw0KQEAgLTAsMCAr MSwxOSBAQA0KK2NvbmZpZyBWSURFT19NRURJQVRFS19GRA0KKwl0cmlzdGF0ZSAiTWVkaWF0ZWsg ZmFjZSBkZXRlY3Rpb24gcHJvY2Vzc2luZyBmdW5jdGlvbiINCisJZGVwZW5kcyBvbiBWSURFT19W NEwyDQorCWRlcGVuZHMgb24gQVJDSF9NRURJQVRFSw0KKwlzZWxlY3QgVklERU9CVUYyX0RNQV9D T05USUcNCisJc2VsZWN0IFZJREVPQlVGMl9DT1JFDQorCXNlbGVjdCBWSURFT0JVRjJfVjRMMg0K KwlzZWxlY3QgVklERU9CVUYyX01FTU9QUw0KKwlzZWxlY3QgTUVESUFfQ09OVFJPTExFUg0KKwlz ZWxlY3QgTVRLX1NDUA0KKw0KKwlkZWZhdWx0IG4NCisJaGVscA0KKwkJU3VwcG9ydCB0aGUgRmFj ZSBEZXRlY3Rpb24gKEZEKSBmZWF0dXJlIGluIHRoZSBNZWRpYXRlaw0KKwkJbXQ4MTgzIFNvYy4N CisNCisJCUZEIGRyaXZlciBpcyBhIFY0TDIgbWVtb3J5LXRvLW1lbW9yeSBkZXZpY2UgZHJpdmVy IHdoaWNoDQorCQlwcm92aWRlcyBoYXJkd2FyZSBhY2NlbGVyYXRlZCBmYWNlIGRldGVjdGlvbiBm dW5jdGlvbiwNCisJCWl0IGNhbiBkZXRlY3QgZGlmZmVyZW50IHNpemVzIG9mIGZhY2VzIGluIGEg cmF3IGltYWdlLg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWlzcC9m ZC9NYWtlZmlsZSBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWlzcC9mZC9NYWtlZmlsZQ0K bmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4uOWIxYzUwMWQ3M2UxDQot LS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvTWFr ZWZpbGUNCkBAIC0wLDAgKzEsNSBAQA0KKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjANCisNCittdGstZmQtb2JqcyArPSBtdGtfZmRfNDAubw0KKw0KK29iai0kKENPTkZJR19WSURF T19NRURJQVRFS19GRCkgKz0gbXRrLWZkLm8NClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQ0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWlzcC9mZC9tdGtfZmQuaCBi L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWlzcC9mZC9tdGtfZmQuaA0KbmV3IGZpbGUgbW9k ZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4uZDg1YmRjYjcwZDZkDQotLS0gL2Rldi9udWxs DQorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1pc3AvZmQvbXRrX2ZkLmgNCkBAIC0w LDAgKzEsMTQ5IEBADQorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8NCisv Lw0KKy8vIENvcHlyaWdodCAoYykgMjAxOCBNZWRpYVRlayBJbmMuDQorDQorI2lmbmRlZiBfX01U S19GRF9IV19IX18NCisjZGVmaW5lIF9fTVRLX0ZEX0hXX0hfXw0KKw0KKyNpbmNsdWRlIDxsaW51 eC9jb21wbGV0aW9uLmg+DQorI2luY2x1ZGUgPGxpbnV4L2lvLmg+DQorI2luY2x1ZGUgPGxpbnV4 L3R5cGVzLmg+DQorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPg0KKyNpbmNsdWRl IDxtZWRpYS92NGwyLWN0cmxzLmg+DQorI2luY2x1ZGUgPG1lZGlhL3Y0bDItZGV2aWNlLmg+DQor I2luY2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi12NGwyLmg+DQorDQorI2RlZmluZSBNVEtfRkRfT1VU UFVUX01JTl9XSURUSAkJCTI2VQ0KKyNkZWZpbmUgTVRLX0ZEX09VVFBVVF9NSU5fSEVJR0hUCQky NlUNCisjZGVmaW5lIE1US19GRF9PVVRQVVRfTUFYX1dJRFRICQkJNjQwVQ0KKyNkZWZpbmUgTVRL X0ZEX09VVFBVVF9NQVhfSEVJR0hUCQk0ODBVDQorDQorI2RlZmluZSBNVEtfRkRfSFdfRk1UX1ZZ VVkJCQkyDQorI2RlZmluZSBNVEtfRkRfSFdfRk1UX1VZVlkJCQkzDQorI2RlZmluZSBNVEtfRkRf SFdfRk1UX1lWWVUJCQk0DQorI2RlZmluZSBNVEtfRkRfSFdfRk1UX1lVWVYJCQk1DQorI2RlZmlu ZSBNVEtfRkRfSFdfRk1UX1lWVV8yUAkJCTYNCisjZGVmaW5lIE1US19GRF9IV19GTVRfWVVWXzJQ CQkJNw0KKyNkZWZpbmUgTVRLX0ZEX0hXX0ZNVF9VTktOT1dOCQkJOA0KKw0KKyNkZWZpbmUgTVRL X0ZEX0lQSV9DTURfSU5JVAkJCTANCisjZGVmaW5lIE1US19GRF9JUElfQ01EX0lOSVRfQUNLCQkJ MQ0KKyNkZWZpbmUgTVRLX0ZEX0lQSV9DTURfRU5RVUVVRQkJCTINCisjZGVmaW5lIE1US19GRF9J UElfQ01EX0VOUV9BQ0sJCQkzDQorI2RlZmluZSBNVEtfRkRfSVBJX0NNRF9FWElUCQkJNA0KKyNk ZWZpbmUgTVRLX0ZEX0lQSV9DTURfRVhJVF9BQ0sJCQk1DQorI2RlZmluZSBNVEtfRkRfSVBJX0NN RF9SRVNFVAkJCTYNCisjZGVmaW5lIE1US19GRF9JUElfQ01EX1JFU0VUX0FDSwkJNw0KKw0KKyNk ZWZpbmUgTVRLX0ZEX1JFR19PRkZTRVRfSFdfRU5BQkxFCQkweDQNCisjZGVmaW5lIE1US19GRF9S RUdfT0ZGU0VUX0lOVF9FTgkJMHgxNWMNCisjZGVmaW5lIE1US19GRF9SRUdfT0ZGU0VUX0lOVF9W QUwJCTB4MTY4DQorI2RlZmluZSBNVEtfRkRfUkVHX09GRlNFVF9SRVNVTFQJCTB4MTc4DQorDQor I2RlZmluZSBNVEtfRkRfU0VUX0hXX0VOQUJMRQkJCTB4MTExDQorI2RlZmluZSBNVEtfRkRfUlNf QlVGX1NJWkUJCQkyMjg5NjY0DQorI2RlZmluZSBNVEtfRkRfSFdfV09SS19CVUZfU0laRQkJCTB4 MTAwMDAwDQorI2RlZmluZSBNVEtfRkRfTUFYX1NQRUVEVVAJCQk3DQorI2RlZmluZSBNVEtfRkRf TUFYX1JFU1VMVF9OVU0JCQkxMDI2DQorDQorLyogTWF4IHNjYWxlIHNpemUgY291bnRzICovDQor I2RlZmluZSBNVEtfRkRfU0NBTEVfQVJSX05VTQkJCTE1DQorDQorI2RlZmluZSBNVEtfRkRfSFdf VElNRU9VVAkJCTEwMDANCisNCitlbnVtIGZhY2VfYW5nbGUgew0KKwlNVEtfRkRfRkFDRV9GUk9O VCwNCisJTVRLX0ZEX0ZBQ0VfUklHSFRfNTAsDQorCU1US19GRF9GQUNFX0xFRlRfNTAsDQorCU1U S19GRF9GQUNFX1JJR0hUXzkwLA0KKwlNVEtfRkRfRkFDRV9MRUZUXzkwLA0KKwlNVEtfRkRfRkFD RV9BTkdMRV9OVU0sDQorfTsNCisNCitzdHJ1Y3QgZmRfYnVmZmVyIHsNCisJX191MzIgc2NwX2Fk ZHI7CS8qIHVzZWQgYnkgU0NQICovDQorCV9fdTMyIGRtYV9hZGRyOwkvKiB1c2VkIGJ5IERNQSBI VyAqLw0KK30gX19wYWNrZWQ7DQorDQorc3RydWN0IGZkX2ZhY2VfcmVzdWx0IHsNCisJY2hhciBk YXRhWzE2XTsNCit9Ow0KKw0KK3N0cnVjdCBmZF91c2VyX291dHB1dCB7DQorCXN0cnVjdCBmZF9m YWNlX3Jlc3VsdCByZXN1bHRzW01US19GRF9NQVhfUkVTVUxUX05VTV07DQorCV9fdTE2IG51bWJl cjsNCit9Ow0KKw0KK3N0cnVjdCB1c2VyX3BhcmFtIHsNCisJdTggZmRfc3BlZWR1cDsNCisJdTgg ZmRfZXh0cmFfbW9kZWw7DQorCXU4IHNjYWxlX2ltZ19udW07DQorCXU4IHNyY19pbWdfZm10Ow0K KwlfX3UxNiBzY2FsZV9pbWdfd2lkdGhbTVRLX0ZEX1NDQUxFX0FSUl9OVU1dOw0KKwlfX3UxNiBz Y2FsZV9pbWdfaGVpZ2h0W01US19GRF9TQ0FMRV9BUlJfTlVNXTsNCisJX191MTYgZmFjZV9kaXJl Y3Rpb25zW01US19GRF9GQUNFX0FOR0xFX05VTV07DQorfSBfX3BhY2tlZDsNCisNCitzdHJ1Y3Qg ZmRfaW5pdF9wYXJhbSB7DQorCXN0cnVjdCBmZF9idWZmZXIgZmRfbWFuYWdlcjsNCisJX191MzIg cnNfZG1hX2FkZHI7DQorfSBfX3BhY2tlZDsNCisNCitzdHJ1Y3QgZmRfZW5xX3BhcmFtIHsNCisJ X191NjQgb3V0cHV0X3ZhZGRyOw0KKwlzdHJ1Y3QgZmRfYnVmZmVyIHNyY19pbWdbMl07DQorCXN0 cnVjdCBmZF9idWZmZXIgdXNlcl9yZXN1bHQ7DQorCXN0cnVjdCB1c2VyX3BhcmFtIHVzZXJfcGFy YW07DQorfSBfX3BhY2tlZDsNCisNCitzdHJ1Y3QgZmRfYWNrX3BhcmFtIHsNCisJX191MzIgcmV0 X2NvZGU7DQorCV9fdTMyIHJldF9tc2c7DQorfSBfX3BhY2tlZDsNCisNCitzdHJ1Y3QgaXBpX21l c3NhZ2Ugew0KKwl1OCBjbWRfaWQ7DQorCXVuaW9uIHsNCisJCXN0cnVjdCBmZF9pbml0X3BhcmFt IGZkX2luaXRfcGFyYW07DQorCQlzdHJ1Y3QgZmRfZW5xX3BhcmFtIGZkX2VucV9wYXJhbTsNCisJ CXN0cnVjdCBmZF9hY2tfcGFyYW0gZmRfYWNrX3BhcmFtOw0KKwl9Ow0KK30gX19wYWNrZWQ7DQor DQorc3RydWN0IG10a19mZF9kZXYgew0KKwlzdHJ1Y3QgZGV2aWNlICpkZXY7DQorCXN0cnVjdCBt dGtfZmRfY3R4ICpjdHg7DQorCXN0cnVjdCB2NGwyX2RldmljZSB2NGwyX2RldjsNCisJc3RydWN0 IHY0bDJfbTJtX2RldiAqbTJtX2RldjsNCisJc3RydWN0IG1lZGlhX2RldmljZSBtZGV2Ow0KKwlz dHJ1Y3QgdmlkZW9fZGV2aWNlIHZmZDsNCisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqc2NwX3Bk ZXY7DQorCXN0cnVjdCBjbGsgKmZkX2NsazsNCisJc3RydWN0IHJwcm9jICpycHJvY19oYW5kbGU7 DQorDQorCS8qIExvY2sgZm9yIFY0TDIgb3BlcmF0aW9ucyAqLw0KKwlzdHJ1Y3QgbXV0ZXggdmZk X2xvY2s7DQorDQorCXN0cnVjdCBmZF91c2VyX291dHB1dCAqb3V0cHV0Ow0KKwlzdHJ1Y3QgZmRf YnVmZmVyIHNjcF9tZW07DQorCXZvaWQgX19pb21lbSAqZmRfYmFzZTsNCisJdm9pZCAqcnNfZG1h X2J1ZjsNCisJZG1hX2FkZHJfdCByc19kbWFfaGFuZGxlOw0KKwl2b2lkICpzY3BfbWVtX3ZpcnRf YWRkcjsNCisNCisJdTMyIGZkX3N0cmVhbV9jb3VudDsNCisJc3RydWN0IGNvbXBsZXRpb24gZmRf am9iX2ZpbmlzaGVkOw0KKwlzdHJ1Y3QgZGVsYXllZF93b3JrIGpvYl90aW1lb3V0X3dvcms7DQor fTsNCisNCitzdHJ1Y3QgbXRrX2ZkX2N0eCB7DQorCXN0cnVjdCBtdGtfZmRfZGV2ICpmZF9kZXY7 DQorCXN0cnVjdCBkZXZpY2UgKmRldjsNCisJc3RydWN0IHY0bDJfZmggZmg7DQorCXN0cnVjdCB2 NGwyX2N0cmxfaGFuZGxlciBoZGw7DQorCXN0cnVjdCB2NGwyX3BpeF9mb3JtYXRfbXBsYW5lIHNy Y19mbXQ7DQorCXN0cnVjdCB2NGwyX21ldGFfZm9ybWF0IGRzdF9mbXQ7DQorCXN0cnVjdCB1c2Vy X3BhcmFtIHVzZXJfcGFyYW07DQorfTsNCisNCisjZW5kaWYvKl9fTVRLX0ZEX0hXX0hfXyovDQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstaXNwL2ZkL210a19mZF80MC5j IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstaXNwL2ZkL210a19mZF80MC5jDQpuZXcgZmls ZSBtb2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMDAwMDAwLi40MzY0MjMyZDcwMTMNCi0tLSAvZGV2 L251bGwNCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWlzcC9mZC9tdGtfZmRfNDAu Yw0KQEAgLTAsMCArMSwxMjc5IEBADQorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjANCisvKg0KKyAqIENvcHlyaWdodCAoYykgMjAxOCBNZWRpYVRlayBJbmMuDQorICoNCisgKiBB dXRob3I6IEplcnJ5LWNoIENoZW4gPGplcnJ5LWNoLmNoZW5AbWVkaWF0ZWsuY29tPg0KKyAqDQor ICovDQorDQorI2luY2x1ZGUgPGxpbnV4L2Nsay5oPg0KKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFw cGluZy5oPg0KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4NCisjaW5jbHVkZSA8bGludXgv aW9wb2xsLmg+DQorI2luY2x1ZGUgPGxpbnV4L2ppZmZpZXMuaD4NCisjaW5jbHVkZSA8bGludXgv bW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4NCisjaW5jbHVkZSA8bGlu dXgvb2ZfaXJxLmg+DQorI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3JtLmg+DQorI2luY2x1ZGUg PGxpbnV4L3JlbW90ZXByb2MvbXRrX3NjcC5oPg0KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9k ZXZpY2UuaD4NCisjaW5jbHVkZSA8bGludXgvcG1fcnVudGltZS5oPg0KKyNpbmNsdWRlIDxsaW51 eC9yZW1vdGVwcm9jLmg+DQorI2luY2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi1kbWEtY29udGlnLmg+ DQorI2luY2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi12NGwyLmg+DQorI2luY2x1ZGUgPG1lZGlhL3Y0 bDItaW9jdGwuaD4NCisjaW5jbHVkZSA8bWVkaWEvdjRsMi1ldmVudC5oPg0KKyNpbmNsdWRlIDxt ZWRpYS92NGwyLWN0cmxzLmg+DQorI2luY2x1ZGUgPG1lZGlhL3Y0bDItbWVtMm1lbS5oPg0KKyNp bmNsdWRlIDxtZWRpYS92aWRlb2J1ZjItY29yZS5oPg0KKw0KKyNpbmNsdWRlICJtdGtfZmQuaCIN CisNCisvKiBTZXQgdGhlIGZhY2UgYW5nbGUgYW5kIGRpcmVjdGlvbnMgdG8gYmUgZGV0ZWN0ZWQg Ki8NCisjZGVmaW5lIFY0TDJfQ0lEX01US19GRF9ERVRFQ1RfUE9TRQkJKFY0TDJfQ0lEX1VTRVJf TVRLX0ZEX0JBU0UgKyAxKQ0KKw0KKy8qIFNldCBpbWFnZSB3aWR0aHMgZm9yIGFuIGlucHV0IGlt YWdlIHRvIGJlIHNjYWxlZCBkb3duIGZvciBmYWNlIGRldGVjdGlvbiAqLw0KKyNkZWZpbmUgVjRM Ml9DSURfTVRLX0ZEX1NDQUxFX0RPV05fSU1HX1dJRFRICShWNEwyX0NJRF9VU0VSX01US19GRF9C QVNFICsgMikNCisNCisvKiBTZXQgaW1hZ2UgaGVpZ2h0cyBmb3IgYW4gaW5wdXQgaW1hZ2UgdG8g YmUgc2NhbGVkIGRvd24gZm9yIGZhY2UgZGV0ZWN0aW9uICovDQorI2RlZmluZSBWNEwyX0NJRF9N VEtfRkRfU0NBTEVfRE9XTl9JTUdfSEVJR0hUCShWNEwyX0NJRF9VU0VSX01US19GRF9CQVNFICsg MykNCisNCisvKiBTZXQgdGhlIGxlbmd0aCBvZiBzY2FsZSBkb3duIHNpemUgYXJyYXkgKi8NCisj ZGVmaW5lIFY0TDJfQ0lEX01US19GRF9TQ0FMRV9JTUdfTlVNCQkoVjRMMl9DSURfVVNFUl9NVEtf RkRfQkFTRSArIDQpDQorDQorLyogU2V0IHRoZSBkZXRlY3Rpb24gc3BlZWQsIHVzdWFsbHkgcmVk dWNpbmcgYWNjdXJhY3kuICovDQorI2RlZmluZSBWNEwyX0NJRF9NVEtfRkRfREVURUNUX1NQRUVE CQkoVjRMMl9DSURfVVNFUl9NVEtfRkRfQkFTRSArIDUpDQorDQorLyogU2VsZWN0IHRoZSBkZXRl Y3Rpb24gbW9kZWwgb3IgYWxnb3JpdGhtIHRvIGJlIHVzZWQuICovDQorI2RlZmluZSBWNEwyX0NJ RF9NVEtfRkRfREVURUNUSU9OX01PREVMCQkoVjRMMl9DSURfVVNFUl9NVEtfRkRfQkFTRSArIDYp DQorDQorLyogV2UgcmVzZXJ2ZSAxNiBjb250cm9scyBmb3IgdGhpcyBkcml2ZXIuICovDQorI2Rl ZmluZSBWNEwyX0NJRF9NVEtfRkRfTUFYCQkJMTYNCisNCitzdGF0aWMgY29uc3Qgc3RydWN0IHY0 bDJfcGl4X2Zvcm1hdF9tcGxhbmUgbXRrX2ZkX2ltZ19mbXRzW10gPSB7DQorCXsNCisJCS5waXhl bGZvcm1hdCA9IFY0TDJfUElYX0ZNVF9WWVVZLA0KKwkJLm51bV9wbGFuZXMgPSAxLA0KKwl9LA0K Kwl7DQorCQkucGl4ZWxmb3JtYXQgPSBWNEwyX1BJWF9GTVRfWVVZViwNCisJCS5udW1fcGxhbmVz ID0gMSwNCisJfSwNCisJew0KKwkJLnBpeGVsZm9ybWF0ID0gVjRMMl9QSVhfRk1UX1lWWVUsDQor CQkubnVtX3BsYW5lcyA9IDEsDQorCX0sDQorCXsNCisJCS5waXhlbGZvcm1hdCA9IFY0TDJfUElY X0ZNVF9VWVZZLA0KKwkJLm51bV9wbGFuZXMgPSAxLA0KKwl9LA0KKwl7DQorCQkucGl4ZWxmb3Jt YXQgPSBWNEwyX1BJWF9GTVRfTlYxNk0sDQorCQkubnVtX3BsYW5lcyA9IDIsDQorCX0sDQorCXsN CisJCS5waXhlbGZvcm1hdCA9IFY0TDJfUElYX0ZNVF9OVjYxTSwNCisJCS5udW1fcGxhbmVzID0g MiwNCisJfSwNCit9Ow0KKw0KKyNkZWZpbmUgTlVNX0ZPUk1BVFMgQVJSQVlfU0laRShtdGtfZmRf aW1nX2ZtdHMpDQorDQorc3RhdGljIGlubGluZSBzdHJ1Y3QgbXRrX2ZkX2N0eCAqZmhfdG9fY3R4 KHN0cnVjdCB2NGwyX2ZoICpmaCkNCit7DQorCXJldHVybiBjb250YWluZXJfb2YoZmgsIHN0cnVj dCBtdGtfZmRfY3R4LCBmaCk7DQorfQ0KKw0KKy8qICAqLw0KK3N0YXRpYyBpbnQgbXRrX2ZkX2h3 X2FsbG9jX3JzX2RtYV9hZGRyKHN0cnVjdCBtdGtfZmRfZGV2ICpmZCkNCit7DQorCXN0cnVjdCBk ZXZpY2UgKmRldiA9IGZkLT5kZXY7DQorCXZvaWQgKnZhOw0KKwlkbWFfYWRkcl90IGRtYV9oYW5k bGU7DQorDQorCXZhID0gZG1hX2FsbG9jX2NvaGVyZW50KGRldiwgTVRLX0ZEX1JTX0JVRl9TSVpF LCAmZG1hX2hhbmRsZSwNCisJCQkJR0ZQX0tFUk5FTCk7DQorCWlmICghdmEpIHsNCisJCWRldl9l cnIoZGV2LCAiZG1hX2FsbG9jIG51bGwgdmFcbiIpOw0KKwkJcmV0dXJuIC1FTk9NRU07DQorCX0N CisJbWVtc2V0KHZhLCAwLCBNVEtfRkRfUlNfQlVGX1NJWkUpOw0KKwlmZC0+cnNfZG1hX2J1ZiA9 IHZhOw0KKwlmZC0+cnNfZG1hX2hhbmRsZSA9IGRtYV9oYW5kbGU7DQorDQorCXJldHVybiAwOw0K K30NCisNCitzdGF0aWMgaW50IG10a19mZF9zZW5kX2lwaV9pbml0KHN0cnVjdCBtdGtfZmRfZGV2 ICpmZCkNCit7DQorCXN0cnVjdCBpcGlfbWVzc2FnZSBmZF9pbml0X21zZzsNCisNCisJZmRfaW5p dF9tc2cuY21kX2lkID0gTVRLX0ZEX0lQSV9DTURfSU5JVDsNCisNCisJZmRfaW5pdF9tc2cuZmRf aW5pdF9wYXJhbS5mZF9tYW5hZ2VyLnNjcF9hZGRyID0gZmQtPnNjcF9tZW0uc2NwX2FkZHI7DQor CWZkX2luaXRfbXNnLmZkX2luaXRfcGFyYW0uZmRfbWFuYWdlci5kbWFfYWRkciA9IGZkLT5zY3Bf bWVtLmRtYV9hZGRyOw0KKw0KKwltZW1zZXQoZmQtPnJzX2RtYV9idWYsIDAsIE1US19GRF9SU19C VUZfU0laRSk7DQorDQorCWZkX2luaXRfbXNnLmZkX2luaXRfcGFyYW0ucnNfZG1hX2FkZHIgPSBm ZC0+cnNfZG1hX2hhbmRsZTsNCisNCisJcmV0dXJuIHNjcF9pcGlfc2VuZChmZC0+c2NwX3BkZXYs IFNDUF9JUElfRkRfQ01ELCAmZmRfaW5pdF9tc2csDQorCQkJICAgIHNpemVvZihmZF9pbml0X21z ZyksIDMwMCk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIG10a19mZF9mcmVlX2RtYV9oYW5kbGUoc3Ry dWN0IG10a19mZF9kZXYgKmZkKQ0KK3sNCisJZG1hX2ZyZWVfY29oZXJlbnQoZmQtPmRldiwgTVRL X0ZEX1JTX0JVRl9TSVpFLA0KKwkJCSAgZmQtPnJzX2RtYV9idWYsDQorCQkJICBmZC0+cnNfZG1h X2hhbmRsZSk7DQorfQ0KKw0KK3N0YXRpYyBpbnQgbXRrX2ZkX2h3X2VuYWJsZShzdHJ1Y3QgbXRr X2ZkX2RldiAqZmQpDQorew0KKwlpbnQgcmV0Ow0KKw0KKwlwbV9ydW50aW1lX2dldF9zeW5jKGZk LT5kZXYpOw0KKwlyZXQgPSBtdGtfZmRfc2VuZF9pcGlfaW5pdChmZCk7DQorCXBtX3J1bnRpbWVf cHV0KGZkLT5kZXYpOw0KKwlpZiAocmV0KSB7DQorCQlkZXZfZXJyKGZkLT5kZXYsICJGYWlsZWQg dG8gc2VuZCBmZCBpcGkgaW5pdFxuIik7DQorCQlyZXR1cm4gcmV0Ow0KKwl9DQorCXJldHVybiAw Ow0KK30NCisNCitzdGF0aWMgdm9pZCBtdGtfZmRfaHdfam9iX2ZpbmlzaChzdHJ1Y3QgbXRrX2Zk X2RldiAqZmQsDQorCQkJCSBlbnVtIHZiMl9idWZmZXJfc3RhdGUgdmJfc3RhdGUpDQorew0KKwlz dHJ1Y3QgbXRrX2ZkX2N0eCAqY3R4Ow0KKwlzdHJ1Y3QgdmIyX3Y0bDJfYnVmZmVyICpzcmNfdmJ1 ZiA9IE5VTEwsICpkc3RfdmJ1ZiA9IE5VTEw7DQorDQorCXBtX3J1bnRpbWVfcHV0KGZkLT5kZXYp Ow0KKw0KKwljdHggPSB2NGwyX20ybV9nZXRfY3Vycl9wcml2KGZkLT5tMm1fZGV2KTsNCisJc3Jj X3ZidWYgPSB2NGwyX20ybV9zcmNfYnVmX3JlbW92ZShjdHgtPmZoLm0ybV9jdHgpOw0KKwlkc3Rf dmJ1ZiA9IHY0bDJfbTJtX2RzdF9idWZfcmVtb3ZlKGN0eC0+ZmgubTJtX2N0eCk7DQorDQorCXY0 bDJfbTJtX2J1Zl9jb3B5X21ldGFkYXRhKHNyY192YnVmLCBkc3RfdmJ1ZiwNCisJCQkJICAgVjRM Ml9CVUZfRkxBR19UU1RBTVBfU1JDX01BU0spOw0KKwl2NGwyX20ybV9idWZfZG9uZShzcmNfdmJ1 ZiwgdmJfc3RhdGUpOw0KKwl2NGwyX20ybV9idWZfZG9uZShkc3RfdmJ1ZiwgdmJfc3RhdGUpOw0K Kwl2NGwyX20ybV9qb2JfZmluaXNoKGZkLT5tMm1fZGV2LCBjdHgtPmZoLm0ybV9jdHgpOw0KKwlj b21wbGV0ZV9hbGwoJmZkLT5mZF9qb2JfZmluaXNoZWQpOw0KK30NCisNCitzdGF0aWMgdm9pZCBt dGtfZmRfaHdfZG9uZShzdHJ1Y3QgbXRrX2ZkX2RldiAqZmQsDQorCQkJICAgZW51bSB2YjJfYnVm ZmVyX3N0YXRlIHZiX3N0YXRlKQ0KK3sNCisJaWYgKCFjYW5jZWxfZGVsYXllZF93b3JrKCZmZC0+ am9iX3RpbWVvdXRfd29yaykpDQorCQlyZXR1cm47DQorDQorCW10a19mZF9od19qb2JfZmluaXNo KGZkLCB2Yl9zdGF0ZSk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIG10a19mZF9pcGlfaGFuZGxlcih2 b2lkICpkYXRhLCB1bnNpZ25lZCBpbnQgbGVuLCB2b2lkICpwcml2KQ0KK3sNCisJc3RydWN0IG10 a19mZF9kZXYgKmZkID0gKHN0cnVjdCBtdGtfZmRfZGV2ICopcHJpdjsNCisJc3RydWN0IGRldmlj ZSAqZGV2ID0gZmQtPmRldjsNCisJc3RydWN0IGlwaV9tZXNzYWdlICpmZF9hY2tfbXNnID0gKHN0 cnVjdCBpcGlfbWVzc2FnZSAqKWRhdGE7DQorCXN0cnVjdCBmZF9hY2tfcGFyYW0gKmZkX2FjayA9 ICZmZF9hY2tfbXNnLT5mZF9hY2tfcGFyYW07DQorDQorCWRldl9kYmcoZmQtPmRldiwgImZkX2lw aV9hY2tfaWQ6ICVkXG4iLCBmZF9hY2tfbXNnLT5jbWRfaWQpOw0KKwlzd2l0Y2ggKGZkX2Fja19t c2ctPmNtZF9pZCkgew0KKwljYXNlIE1US19GRF9JUElfQ01EX0lOSVRfQUNLOg0KKwkJcmV0dXJu Ow0KKwljYXNlIE1US19GRF9JUElfQ01EX0VOUV9BQ0s6DQorCQlpZiAoZmRfYWNrLT5yZXRfY29k ZSkgew0KKwkJCWRldl9lcnIoZGV2LCAiaXBpIHJldDogJWQsIG1lc3NhZ2U6ICVkXG4iLA0KKwkJ CQlmZF9hY2stPnJldF9jb2RlLCBmZF9hY2stPnJldF9tc2cpOw0KKwkJCW10a19mZF9od19kb25l KGZkLCBWQjJfQlVGX1NUQVRFX0VSUk9SKTsNCisJCX0NCisJCXJldHVybjsNCisJY2FzZSBNVEtf RkRfSVBJX0NNRF9FWElUX0FDSzoNCisJCWlmIChmZF9hY2stPnJldF9jb2RlKQ0KKwkJCWRldl9l cnIoZGV2LCAiRmFpbGVkIHRvIGV4aXQgRkQgSFdcbiIpOw0KKwkJcmV0dXJuOw0KKwljYXNlIE1U S19GRF9JUElfQ01EX1JFU0VUX0FDSzoNCisJCWlmIChmZF9hY2stPnJldF9jb2RlKQ0KKwkJCWRl dl9lcnIoZGV2LCAiRmFpbGVkIHRvIHJlc2V0IEZEIEhXXG4iKTsNCisJCXJldHVybjsNCisJfQ0K K30NCisNCitzdGF0aWMgaW50IG10a19mZF9od19jb25uZWN0KHN0cnVjdCBtdGtfZmRfZGV2ICpm ZCkNCit7DQorCWludCByZXQ7DQorDQorCXJldCA9IHJwcm9jX2Jvb3QoZmQtPnJwcm9jX2hhbmRs ZSk7DQorDQorCWlmIChyZXQgPCAwKSB7DQorCQkvKioNCisJCSAqIFJldHVybiAwIGlmIGRvd25s b2FkaW5nIGZpcm13YXJlIHN1Y2Nlc3NmdWxseSwNCisJCSAqIG90aGVyd2lzZSBpdCBpcyBmYWls ZWQNCisJCSAqLw0KKwkJZGV2X2VycihmZC0+ZGV2LCAiRmFpbGVkIHRvIGJvb3QgcnByb2NcbiIp Ow0KKwkJcmV0dXJuIHJldDsNCisJfQ0KKw0KKwlyZXQgPSBzY3BfaXBpX3JlZ2lzdGVyKGZkLT5z Y3BfcGRldiwgU0NQX0lQSV9GRF9DTUQsDQorCQkJICAgICAgIG10a19mZF9pcGlfaGFuZGxlciwg ZmQpOw0KKwlpZiAocmV0KSB7DQorCQlkZXZfZXJyKGZkLT5kZXYsICJGYWlsZWQgdG8gcmVnaXN0 ZXIgSVBJIGNtZCBoYW5kbGVyXG4iKTsNCisJCWdvdG8gZXJyX3Jwcm9jX3NodXRkb3duOw0KKwl9 DQorDQorCWZkLT5mZF9zdHJlYW1fY291bnQrKzsNCisJaWYgKGZkLT5mZF9zdHJlYW1fY291bnQg PT0gMSkgew0KKwkJaWYgKG10a19mZF9od19lbmFibGUoZmQpKSB7DQorCQkJcmV0ID0gLUVJTlZB TDsNCisJCQlnb3RvIGVycl9ycHJvY19zaHV0ZG93bjsNCisJCX0NCisJfQ0KKwlyZXR1cm4gMDsN CisNCitlcnJfcnByb2Nfc2h1dGRvd246DQorCXJwcm9jX3NodXRkb3duKGZkLT5ycHJvY19oYW5k bGUpOw0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCitzdGF0aWMgdm9pZCBtdGtfZmRfZXhpdF9odyhz dHJ1Y3QgbXRrX2ZkX2RldiAqZmQpDQorew0KKwlzdHJ1Y3QgaXBpX21lc3NhZ2UgZmRfaXBpX21z ZzsNCisNCisJZmRfaXBpX21zZy5jbWRfaWQgPSBNVEtfRkRfSVBJX0NNRF9FWElUOw0KKwlpZiAo c2NwX2lwaV9zZW5kKGZkLT5zY3BfcGRldiwgU0NQX0lQSV9GRF9DTUQsICZmZF9pcGlfbXNnLA0K KwkJCSBzaXplb2YoZmRfaXBpX21zZyksIDMwMCkpDQorCQlkZXZfZXJyKGZkLT5kZXYsICJGRCBF WElUIEhXIGVycm9yXG4iKTsNCit9DQorDQorc3RhdGljIHZvaWQgbXRrX2ZkX2h3X2Rpc2Nvbm5l Y3Qoc3RydWN0IG10a19mZF9kZXYgKmZkKQ0KK3sNCisJZmQtPmZkX3N0cmVhbV9jb3VudC0tOw0K KwltdGtfZmRfZXhpdF9odyhmZCk7DQorCXJwcm9jX3NodXRkb3duKGZkLT5ycHJvY19oYW5kbGUp Ow0KK30NCisNCitzdGF0aWMgaW50IG10a19mZF9od19qb2JfZXhlYyhzdHJ1Y3QgbXRrX2ZkX2Rl diAqZmQsDQorCQkJICAgICAgc3RydWN0IGZkX2VucV9wYXJhbSAqZmRfcGFyYW0pDQorew0KKwlz dHJ1Y3QgaXBpX21lc3NhZ2UgZmRfaXBpX21zZzsNCisJaW50IHJldDsNCisNCisJcG1fcnVudGlt ZV9nZXRfc3luYygoZmQtPmRldikpOw0KKw0KKwlyZWluaXRfY29tcGxldGlvbigmZmQtPmZkX2pv Yl9maW5pc2hlZCk7DQorCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmZmQtPmpvYl90aW1lb3V0X3dv cmssDQorCQkJICAgICAgbXNlY3NfdG9famlmZmllcyhNVEtfRkRfSFdfVElNRU9VVCkpOw0KKw0K KwlmZF9pcGlfbXNnLmNtZF9pZCA9IE1US19GRF9JUElfQ01EX0VOUVVFVUU7DQorCW1lbWNweSgm ZmRfaXBpX21zZy5mZF9lbnFfcGFyYW0sIGZkX3BhcmFtLCBzaXplb2Yoc3RydWN0IGZkX2VucV9w YXJhbSkpOw0KKwlyZXQgPSBzY3BfaXBpX3NlbmQoZmQtPnNjcF9wZGV2LCBTQ1BfSVBJX0ZEX0NN RCwgJmZkX2lwaV9tc2csDQorCQkJICAgc2l6ZW9mKGZkX2lwaV9tc2cpLCAzMDApOw0KKwlpZiAo cmV0KSB7DQorCQltdGtfZmRfaHdfZG9uZShmZCwgVkIyX0JVRl9TVEFURV9FUlJPUik7DQorCQly ZXR1cm4gcmV0Ow0KKwl9DQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50IG10a19mZF92 YjJfYnVmX291dF92YWxpZGF0ZShzdHJ1Y3QgdmIyX2J1ZmZlciAqdmIpDQorew0KKwlzdHJ1Y3Qg dmIyX3Y0bDJfYnVmZmVyICp2NGwyX2J1ZiA9IHRvX3ZiMl92NGwyX2J1ZmZlcih2Yik7DQorDQor CWlmICh2NGwyX2J1Zi0+ZmllbGQgPT0gVjRMMl9GSUVMRF9BTlkpDQorCQl2NGwyX2J1Zi0+Zmll bGQgPSBWNEwyX0ZJRUxEX05PTkU7DQorCWlmICh2NGwyX2J1Zi0+ZmllbGQgIT0gVjRMMl9GSUVM RF9OT05FKQ0KKwkJcmV0dXJuIC1FSU5WQUw7DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0 aWMgaW50IG10a19mZF92YjJfYnVmX3ByZXBhcmUoc3RydWN0IHZiMl9idWZmZXIgKnZiKQ0KK3sN CisJc3RydWN0IHZiMl92NGwyX2J1ZmZlciAqdmJ1ZiA9IHRvX3ZiMl92NGwyX2J1ZmZlcih2Yik7 DQorCXN0cnVjdCB2YjJfcXVldWUgKnZxID0gdmItPnZiMl9xdWV1ZTsNCisJc3RydWN0IG10a19m ZF9jdHggKmN0eCA9IHZiMl9nZXRfZHJ2X3ByaXYodnEpOw0KKwlzdHJ1Y3QgZGV2aWNlICpkZXYg PSBjdHgtPmRldjsNCisJc3RydWN0IHY0bDJfcGl4X2Zvcm1hdF9tcGxhbmUgKnBpeGZtdDsNCisN CisJc3dpdGNoICh2cS0+dHlwZSkgew0KKwljYXNlIFY0TDJfQlVGX1RZUEVfTUVUQV9DQVBUVVJF Og0KKwkJaWYgKHZiMl9wbGFuZV9zaXplKHZiLCAwKSA8IGN0eC0+ZHN0X2ZtdC5idWZmZXJzaXpl KSB7DQorCQkJZGV2X2RiZyhkZXYsICJtZXRhIHNpemUgJWx1IGlzIHRvbyBzbWFsbFxuIiwNCisJ CQkJdmIyX3BsYW5lX3NpemUodmIsIDApKTsNCisJCQlyZXR1cm4gLUVJTlZBTDsNCisJCX0NCisJ CWJyZWFrOw0KKwljYXNlIFY0TDJfQlVGX1RZUEVfVklERU9fT1VUUFVUX01QTEFORToNCisJCXBp eGZtdCA9ICZjdHgtPnNyY19mbXQ7DQorDQorCQlpZiAodmJ1Zi0+ZmllbGQgPT0gVjRMMl9GSUVM RF9BTlkpDQorCQkJdmJ1Zi0+ZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7DQorDQorCQlpZiAodmIt Pm51bV9wbGFuZXMgPiAyIHx8IHZidWYtPmZpZWxkICE9IFY0TDJfRklFTERfTk9ORSkgew0KKwkJ CWRldl9kYmcoZGV2LCAicGxhbmUgJWQgb3IgZmllbGQgJWQgbm90IHN1cHBvcnRlZFxuIiwNCisJ CQkJdmItPm51bV9wbGFuZXMsIHZidWYtPmZpZWxkKTsNCisJCQlyZXR1cm4gLUVJTlZBTDsNCisJ CX0NCisJCWlmICh2YjJfcGxhbmVfc2l6ZSh2YiwgMCkgPCBwaXhmbXQtPnBsYW5lX2ZtdFswXS5z aXplaW1hZ2UpIHsNCisJCQlkZXZfZGJnKGRldiwgInBsYW5lICVsdSBpcyB0b28gc21hbGxcbiIs DQorCQkJCXZiMl9wbGFuZV9zaXplKHZiLCAwKSk7DQorCQkJcmV0dXJuIC1FSU5WQUw7DQorCQl9 DQorCQlicmVhazsNCisJfQ0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIHZvaWQgbXRr X2ZkX3ZiMl9idWZfcXVldWUoc3RydWN0IHZiMl9idWZmZXIgKnZiKQ0KK3sNCisJc3RydWN0IG10 a19mZF9jdHggKmN0eCA9IHZiMl9nZXRfZHJ2X3ByaXYodmItPnZiMl9xdWV1ZSk7DQorCXN0cnVj dCB2YjJfdjRsMl9idWZmZXIgKnZidWYgPSB0b192YjJfdjRsMl9idWZmZXIodmIpOw0KKw0KKwl2 NGwyX20ybV9idWZfcXVldWUoY3R4LT5maC5tMm1fY3R4LCB2YnVmKTsNCit9DQorDQorc3RhdGlj IGludCBtdGtfZmRfdmIyX3F1ZXVlX3NldHVwKHN0cnVjdCB2YjJfcXVldWUgKnZxLA0KKwkJCQkg IHVuc2lnbmVkIGludCAqbnVtX2J1ZmZlcnMsDQorCQkJCSAgdW5zaWduZWQgaW50ICpudW1fcGxh bmVzLA0KKwkJCQkgIHVuc2lnbmVkIGludCBzaXplc1tdLA0KKwkJCQkgIHN0cnVjdCBkZXZpY2Ug KmFsbG9jX2RldnNbXSkNCit7DQorCXN0cnVjdCBtdGtfZmRfY3R4ICpjdHggPSB2YjJfZ2V0X2Ry dl9wcml2KHZxKTsNCisJdW5zaWduZWQgaW50IHNpemVbMl07DQorCXVuc2lnbmVkIGludCBwbGFu ZTsNCisNCisJc3dpdGNoICh2cS0+dHlwZSkgew0KKwljYXNlIFY0TDJfQlVGX1RZUEVfTUVUQV9D QVBUVVJFOg0KKwkJc2l6ZVswXSA9IGN0eC0+ZHN0X2ZtdC5idWZmZXJzaXplOw0KKwkJYnJlYWs7 DQorCWNhc2UgVjRMMl9CVUZfVFlQRV9WSURFT19PVVRQVVRfTVBMQU5FOg0KKwkJc2l6ZVswXSA9 IGN0eC0+c3JjX2ZtdC5wbGFuZV9mbXRbMF0uc2l6ZWltYWdlOw0KKwkJaWYgKCpudW1fcGxhbmVz ID09IDIpDQorCQkJc2l6ZVsxXSA9IGN0eC0+c3JjX2ZtdC5wbGFuZV9mbXRbMV0uc2l6ZWltYWdl Ow0KKwkJYnJlYWs7DQorCX0NCisNCisJaWYgKCpudW1fcGxhbmVzID4gMikNCisJCXJldHVybiAt RUlOVkFMOw0KKwlpZiAoKm51bV9wbGFuZXMgPT0gMCkgew0KKwkJaWYgKHZxLT50eXBlID09IFY0 TDJfQlVGX1RZUEVfTUVUQV9DQVBUVVJFKSB7DQorCQkJc2l6ZXNbMF0gPSBjdHgtPmRzdF9mbXQu YnVmZmVyc2l6ZTsNCisJCQkqbnVtX3BsYW5lcyA9IDE7DQorCQkJcmV0dXJuIDA7DQorCQl9DQor DQorCQkqbnVtX3BsYW5lcyA9IGN0eC0+c3JjX2ZtdC5udW1fcGxhbmVzOw0KKwkJZm9yIChwbGFu ZSA9IDA7IHBsYW5lIDwgKm51bV9wbGFuZXM7IHBsYW5lKyspDQorCQkJc2l6ZXNbcGxhbmVdID0g Y3R4LT5zcmNfZm10LnBsYW5lX2ZtdFtwbGFuZV0uc2l6ZWltYWdlOw0KKwkJcmV0dXJuIDA7DQor CX0NCisNCisJZm9yIChwbGFuZSA9IDA7IHBsYW5lIDwgKm51bV9wbGFuZXM7IHBsYW5lKyspIHsN CisJCWlmIChzaXplc1twbGFuZV0gPCBzaXplW3BsYW5lXSkNCisJCQlyZXR1cm4gLUVJTlZBTDsN CisJfQ0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBtdGtfZmRfdmIyX3N0YXJ0X3N0 cmVhbWluZyhzdHJ1Y3QgdmIyX3F1ZXVlICp2cSwgdW5zaWduZWQgaW50IGNvdW50KQ0KK3sNCisJ c3RydWN0IG10a19mZF9jdHggKmN0eCA9IHZiMl9nZXRfZHJ2X3ByaXYodnEpOw0KKw0KKwlpZiAo dnEtPnR5cGUgPT0gVjRMMl9CVUZfVFlQRV9WSURFT19PVVRQVVRfTVBMQU5FKQ0KKwkJcmV0dXJu IG10a19mZF9od19jb25uZWN0KGN0eC0+ZmRfZGV2KTsNCisJZWxzZQ0KKwkJcmV0dXJuIDA7DQor fQ0KKw0KK3N0YXRpYyB2b2lkIG10a19mZF9yZXNldF9odyhzdHJ1Y3QgbXRrX2ZkX2RldiAqZmQp DQorew0KKwlzdHJ1Y3QgaXBpX21lc3NhZ2UgZmRfaXBpX21zZzsNCisNCisJZmRfaXBpX21zZy5j bWRfaWQgPSBNVEtfRkRfSVBJX0NNRF9SRVNFVDsNCisJaWYgKHNjcF9pcGlfc2VuZChmZC0+c2Nw X3BkZXYsIFNDUF9JUElfRkRfQ01ELCAmZmRfaXBpX21zZywNCisJCQkgc2l6ZW9mKGZkX2lwaV9t c2cpLCAzMDApKQ0KKwkJZGV2X2VycihmZC0+ZGV2LCAiRkQgUmVzZXQgSFcgZXJyb3JcbiIpOw0K K30NCisNCitzdGF0aWMgdm9pZCBtdGtfZmRfam9iX3RpbWVvdXRfd29yayhzdHJ1Y3Qgd29ya19z dHJ1Y3QgKndvcmspDQorew0KKwlzdHJ1Y3QgbXRrX2ZkX2RldiAqZmQgPQ0KKwkJY29udGFpbmVy X29mKHdvcmssIHN0cnVjdCBtdGtfZmRfZGV2LCBqb2JfdGltZW91dF93b3JrLndvcmspOw0KKw0K KwlkZXZfZXJyKGZkLT5kZXYsICJGRCBKb2IgdGltZW91dCEiKTsNCisJbXRrX2ZkX3Jlc2V0X2h3 KGZkKTsNCisJbXRrX2ZkX2h3X2pvYl9maW5pc2goZmQsIFZCMl9CVUZfU1RBVEVfRVJST1IpOw0K K30NCisNCitzdGF0aWMgdm9pZCBtdGtfZmRfam9iX3dhaXRfZmluaXNoKHN0cnVjdCBtdGtfZmRf ZGV2ICpmZCkNCit7DQorCXdhaXRfZm9yX2NvbXBsZXRpb24oJmZkLT5mZF9qb2JfZmluaXNoZWQp Ow0KK30NCisNCitzdGF0aWMgdm9pZCBtdGtfZmRfdmIyX3N0b3Bfc3RyZWFtaW5nKHN0cnVjdCB2 YjJfcXVldWUgKnZxKQ0KK3sNCisJc3RydWN0IG10a19mZF9jdHggKmN0eCA9IHZiMl9nZXRfZHJ2 X3ByaXYodnEpOw0KKwlzdHJ1Y3QgbXRrX2ZkX2RldiAqZmQgPSBjdHgtPmZkX2RldjsNCisJc3Ry dWN0IHZiMl92NGwyX2J1ZmZlciAqdmI7DQorCXN0cnVjdCB2NGwyX20ybV9jdHggKm0ybV9jdHgg PSBjdHgtPmZoLm0ybV9jdHg7DQorCXN0cnVjdCB2NGwyX20ybV9xdWV1ZV9jdHggKnF1ZXVlX2N0 eDsNCisNCisJbXRrX2ZkX2pvYl93YWl0X2ZpbmlzaChmZCk7DQorCXF1ZXVlX2N0eCA9IFY0TDJf VFlQRV9JU19PVVRQVVQodnEtPnR5cGUpID8NCisJCQkJCSZtMm1fY3R4LT5vdXRfcV9jdHggOg0K KwkJCQkJJm0ybV9jdHgtPmNhcF9xX2N0eDsNCisJd2hpbGUgKCh2YiA9IHY0bDJfbTJtX2J1Zl9y ZW1vdmUocXVldWVfY3R4KSkpDQorCQl2NGwyX20ybV9idWZfZG9uZSh2YiwgVkIyX0JVRl9TVEFU RV9FUlJPUik7DQorDQorCWlmICh2cS0+dHlwZSA9PSBWNEwyX0JVRl9UWVBFX1ZJREVPX09VVFBV VF9NUExBTkUpDQorCQltdGtfZmRfaHdfZGlzY29ubmVjdChmZCk7DQorfQ0KKw0KK3N0YXRpYyB2 b2lkIG10a19mZF92YjJfcmVxdWVzdF9jb21wbGV0ZShzdHJ1Y3QgdmIyX2J1ZmZlciAqdmIpDQor ew0KKwlzdHJ1Y3QgbXRrX2ZkX2N0eCAqY3R4ID0gdmIyX2dldF9kcnZfcHJpdih2Yi0+dmIyX3F1 ZXVlKTsNCisNCisJdjRsMl9jdHJsX3JlcXVlc3RfY29tcGxldGUodmItPnJlcV9vYmoucmVxLCAm Y3R4LT5oZGwpOw0KK30NCisNCitzdGF0aWMgaW50IG10a19mZF9xdWVyeWNhcChzdHJ1Y3QgZmls ZSAqZmlsZSwgdm9pZCAqZmgsDQorCQkJICAgc3RydWN0IHY0bDJfY2FwYWJpbGl0eSAqY2FwKQ0K K3sNCisJc3RydWN0IG10a19mZF9kZXYgKmZkID0gdmlkZW9fZHJ2ZGF0YShmaWxlKTsNCisJc3Ry dWN0IGRldmljZSAqZGV2ID0gZmQtPmRldjsNCisNCisJc3Ryc2NweShjYXAtPmRyaXZlciwgZGV2 X2RyaXZlcl9zdHJpbmcoZGV2KSwgc2l6ZW9mKGNhcC0+ZHJpdmVyKSk7DQorCXN0cnNjcHkoY2Fw LT5jYXJkLCBkZXZfZHJpdmVyX3N0cmluZyhkZXYpLCBzaXplb2YoY2FwLT5jYXJkKSk7DQorCXNu cHJpbnRmKGNhcC0+YnVzX2luZm8sIHNpemVvZihjYXAtPmJ1c19pbmZvKSwgInBsYXRmb3JtOiVz IiwNCisJCSBkZXZfbmFtZShmZC0+ZGV2KSk7DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0 aWMgaW50IG10a19mZF9lbnVtX2ZtdF9vdXRfbXAoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKmZo LA0KKwkJCQkgIHN0cnVjdCB2NGwyX2ZtdGRlc2MgKmYpDQorew0KKwlpZiAoZi0+aW5kZXggPj0g TlVNX0ZPUk1BVFMpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJZi0+cGl4ZWxmb3JtYXQgPSBt dGtfZmRfaW1nX2ZtdHNbZi0+aW5kZXhdLnBpeGVsZm9ybWF0Ow0KKwlyZXR1cm4gMDsNCit9DQor DQorc3RhdGljIHZvaWQgbXRrX2ZkX2ZpbGxfcGl4Zm10X21wKHN0cnVjdCB2NGwyX3BpeF9mb3Jt YXRfbXBsYW5lICpkZm10LA0KKwkJCQkgIGNvbnN0IHN0cnVjdCB2NGwyX3BpeF9mb3JtYXRfbXBs YW5lICpzZm10KQ0KK3sNCisJZGZtdC0+ZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7DQorCWRmbXQt PmNvbG9yc3BhY2UgPSBWNEwyX0NPTE9SU1BBQ0VfQlQyMDIwOw0KKwlkZm10LT5udW1fcGxhbmVz ID0gc2ZtdC0+bnVtX3BsYW5lczsNCisJZGZtdC0+eWNiY3JfZW5jID0gVjRMMl9ZQ0JDUl9FTkNf REVGQVVMVDsNCisJZGZtdC0+cXVhbnRpemF0aW9uID0gVjRMMl9RVUFOVElaQVRJT05fREVGQVVM VDsNCisJZGZtdC0+eGZlcl9mdW5jID0NCisJCVY0TDJfTUFQX1hGRVJfRlVOQ19ERUZBVUxUKGRm bXQtPmNvbG9yc3BhY2UpOw0KKw0KKwkvKiBLZWVwIHVzZXIgc2V0dGluZyBhcyBwb3NzaWJsZSAq Lw0KKwlkZm10LT53aWR0aCA9IGNsYW1wKGRmbXQtPndpZHRoLA0KKwkJCSAgICBNVEtfRkRfT1VU UFVUX01JTl9XSURUSCwNCisJCQkgICAgTVRLX0ZEX09VVFBVVF9NQVhfV0lEVEgpOw0KKwlkZm10 LT5oZWlnaHQgPSBjbGFtcChkZm10LT5oZWlnaHQsDQorCQkJICAgICBNVEtfRkRfT1VUUFVUX01J Tl9IRUlHSFQsDQorCQkJICAgICBNVEtfRkRfT1VUUFVUX01BWF9IRUlHSFQpOw0KKw0KKwlpZiAo c2ZtdC0+bnVtX3BsYW5lcyA9PSAyKSB7DQorCQkvKiBOVjE2TSBhbmQgTlY2MU0gaGFzIDEgYnl0 ZSBwZXIgcGl4ZWwgKi8NCisJCWRmbXQtPnBsYW5lX2ZtdFswXS5ieXRlc3BlcmxpbmUgPSBkZm10 LT53aWR0aDsNCisJCWRmbXQtPnBsYW5lX2ZtdFsxXS5ieXRlc3BlcmxpbmUgPSBkZm10LT53aWR0 aDsNCisJfSBlbHNlIHsNCisJCS8qIDIgYnl0ZXMgcGVyIHBpeGVsICovDQorCQlkZm10LT5wbGFu ZV9mbXRbMF0uYnl0ZXNwZXJsaW5lID0gZGZtdC0+d2lkdGggKiAyOw0KKwl9DQorDQorCWRmbXQt PnBsYW5lX2ZtdFswXS5zaXplaW1hZ2UgPQ0KKwkJZGZtdC0+aGVpZ2h0ICogZGZtdC0+cGxhbmVf Zm10WzBdLmJ5dGVzcGVybGluZTsNCit9DQorDQorc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX3Bp eF9mb3JtYXRfbXBsYW5lICptdGtfZmRfZmluZF9mbXQodTMyIGZvcm1hdCkNCit7DQorCXVuc2ln bmVkIGludCBpOw0KKwljb25zdCBzdHJ1Y3QgdjRsMl9waXhfZm9ybWF0X21wbGFuZSAqZGV2X2Zt dDsNCisNCisJZm9yIChpID0gMDsgaSA8IE5VTV9GT1JNQVRTOyBpKyspIHsNCisJCWRldl9mbXQg PSAmbXRrX2ZkX2ltZ19mbXRzW2ldOw0KKwkJaWYgKGRldl9mbXQtPnBpeGVsZm9ybWF0ID09IGZv cm1hdCkNCisJCQlyZXR1cm4gZGV2X2ZtdDsNCisJfQ0KKw0KKwlyZXR1cm4gTlVMTDsNCit9DQor DQorc3RhdGljIGludCBtdGtfZmRfdHJ5X2ZtdF9vdXRfbXAoc3RydWN0IGZpbGUgKmZpbGUsDQor CQkJCSB2b2lkICpmaCwNCisJCQkJIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCit7DQorCXN0cnVj dCB2NGwyX3BpeF9mb3JtYXRfbXBsYW5lICpwaXhfbXAgPSAmZi0+Zm10LnBpeF9tcDsNCisJY29u c3Qgc3RydWN0IHY0bDJfcGl4X2Zvcm1hdF9tcGxhbmUgKmZtdDsNCisNCisJZm10ID0gbXRrX2Zk X2ZpbmRfZm10KHBpeF9tcC0+cGl4ZWxmb3JtYXQpOw0KKwlpZiAoIWZtdCkNCisJCWZtdCA9ICZt dGtfZmRfaW1nX2ZtdHNbMF07CS8qIEdldCBkZWZhdWx0IGltZyBmbXQgKi8NCisNCisJbXRrX2Zk X2ZpbGxfcGl4Zm10X21wKHBpeF9tcCwgZm10KTsNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRp YyBpbnQgbXRrX2ZkX2dfZm10X291dF9tcChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZmgsDQor CQkJICAgICAgIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCit7DQorCXN0cnVjdCBtdGtfZmRfY3R4 ICpjdHggPSBmaF90b19jdHgoZmgpOw0KKw0KKwlmLT5mbXQucGl4X21wID0gY3R4LT5zcmNfZm10 Ow0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBtdGtfZmRfc19mbXRfb3V0X21w KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpmaCwNCisJCQkgICAgICAgc3RydWN0IHY0bDJfZm9y bWF0ICpmKQ0KK3sNCisJc3RydWN0IG10a19mZF9jdHggKmN0eCA9IGZoX3RvX2N0eChmaCk7DQor CXN0cnVjdCB2YjJfcXVldWUgKnZxID0gdjRsMl9tMm1fZ2V0X3ZxKGN0eC0+ZmgubTJtX2N0eCwg Zi0+dHlwZSk7DQorDQorCS8qIENoYW5nZSBub3QgYWxsb3dlZCBpZiBxdWV1ZSBpcyBzdHJlYW1p bmcuICovDQorCWlmICh2YjJfaXNfc3RyZWFtaW5nKHZxKSkgew0KKwkJZGV2X2VycihjdHgtPmRl diwgIkZhaWxlZCB0byBzZXQgZm9ybWF0LCB2YjIgaXMgYnVzeVxuIik7DQorCQlyZXR1cm4gLUVC VVNZOw0KKwl9DQorDQorCW10a19mZF90cnlfZm10X291dF9tcChmaWxlLCBmaCwgZik7DQorCWN0 eC0+c3JjX2ZtdCA9IGYtPmZtdC5waXhfbXA7DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0 aWMgaW50IG10a19mZF9lbnVtX2ZtdF9tZXRhX2NhcChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAq ZmgsDQorCQkJCSAgICBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KK3sNCisJaWYgKGYtPmluZGV4 KQ0KKwkJcmV0dXJuIC1FSU5WQUw7DQorDQorCXN0cnNjcHkoZi0+ZGVzY3JpcHRpb24sICJGYWNl IGRldGVjdGlvbiByZXN1bHQiLA0KKwkJc2l6ZW9mKGYtPmRlc2NyaXB0aW9uKSk7DQorCWYtPnBp eGVsZm9ybWF0ID0gVjRMMl9NRVRBX0ZNVF9NVEZEX1JFU1VMVDsNCisJZi0+ZmxhZ3MgPSAwOw0K Kw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBtdGtfZmRfZ19mbXRfbWV0YV9jYXAo c3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKmZoLA0KKwkJCQkgc3RydWN0IHY0bDJfZm9ybWF0ICpm KQ0KK3sNCisJZi0+Zm10Lm1ldGEuZGF0YWZvcm1hdCA9IFY0TDJfTUVUQV9GTVRfTVRGRF9SRVNV TFQ7DQorCWYtPmZtdC5tZXRhLmJ1ZmZlcnNpemUgPSBzaXplb2Yoc3RydWN0IGZkX3VzZXJfb3V0 cHV0KTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmIyX29w cyBtdGtfZmRfdmIyX29wcyA9IHsNCisJLnF1ZXVlX3NldHVwID0gbXRrX2ZkX3ZiMl9xdWV1ZV9z ZXR1cCwNCisJLmJ1Zl9vdXRfdmFsaWRhdGUgPSBtdGtfZmRfdmIyX2J1Zl9vdXRfdmFsaWRhdGUs DQorCS5idWZfcHJlcGFyZSAgPSBtdGtfZmRfdmIyX2J1Zl9wcmVwYXJlLA0KKwkuYnVmX3F1ZXVl ID0gbXRrX2ZkX3ZiMl9idWZfcXVldWUsDQorCS5zdGFydF9zdHJlYW1pbmcgPSBtdGtfZmRfdmIy X3N0YXJ0X3N0cmVhbWluZywNCisJLnN0b3Bfc3RyZWFtaW5nID0gbXRrX2ZkX3ZiMl9zdG9wX3N0 cmVhbWluZywNCisJLndhaXRfcHJlcGFyZSA9IHZiMl9vcHNfd2FpdF9wcmVwYXJlLA0KKwkud2Fp dF9maW5pc2ggPSB2YjJfb3BzX3dhaXRfZmluaXNoLA0KKwkuYnVmX3JlcXVlc3RfY29tcGxldGUg PSBtdGtfZmRfdmIyX3JlcXVlc3RfY29tcGxldGUsDQorfTsNCisNCitzdGF0aWMgY29uc3Qgc3Ry dWN0IHY0bDJfaW9jdGxfb3BzIG10a19mZF92NGwyX3ZpZGVvX291dF9pb2N0bF9vcHMgPSB7DQor CS52aWRpb2NfcXVlcnljYXAgPSBtdGtfZmRfcXVlcnljYXAsDQorCS52aWRpb2NfZW51bV9mbXRf dmlkX291dCA9IG10a19mZF9lbnVtX2ZtdF9vdXRfbXAsDQorCS52aWRpb2NfZ19mbXRfdmlkX291 dF9tcGxhbmUgPSBtdGtfZmRfZ19mbXRfb3V0X21wLA0KKwkudmlkaW9jX3NfZm10X3ZpZF9vdXRf bXBsYW5lID0gbXRrX2ZkX3NfZm10X291dF9tcCwNCisJLnZpZGlvY190cnlfZm10X3ZpZF9vdXRf bXBsYW5lID0gbXRrX2ZkX3RyeV9mbXRfb3V0X21wLA0KKwkudmlkaW9jX2VudW1fZm10X21ldGFf Y2FwID0gbXRrX2ZkX2VudW1fZm10X21ldGFfY2FwLA0KKwkudmlkaW9jX2dfZm10X21ldGFfY2Fw ID0gbXRrX2ZkX2dfZm10X21ldGFfY2FwLA0KKwkudmlkaW9jX3NfZm10X21ldGFfY2FwID0gbXRr X2ZkX2dfZm10X21ldGFfY2FwLA0KKwkudmlkaW9jX3RyeV9mbXRfbWV0YV9jYXAgPSBtdGtfZmRf Z19mbXRfbWV0YV9jYXAsDQorCS52aWRpb2NfcmVxYnVmcyA9IHY0bDJfbTJtX2lvY3RsX3JlcWJ1 ZnMsDQorCS52aWRpb2NfY3JlYXRlX2J1ZnMgPSB2NGwyX20ybV9pb2N0bF9jcmVhdGVfYnVmcywN CisJLnZpZGlvY19leHBidWYgPSB2NGwyX20ybV9pb2N0bF9leHBidWYsDQorCS52aWRpb2NfcHJl cGFyZV9idWYgPSB2NGwyX20ybV9pb2N0bF9wcmVwYXJlX2J1ZiwNCisJLnZpZGlvY19xdWVyeWJ1 ZiA9IHY0bDJfbTJtX2lvY3RsX3F1ZXJ5YnVmLA0KKwkudmlkaW9jX3FidWYgPSB2NGwyX20ybV9p b2N0bF9xYnVmLA0KKwkudmlkaW9jX2RxYnVmID0gdjRsMl9tMm1faW9jdGxfZHFidWYsDQorCS52 aWRpb2Nfc3RyZWFtb24gPSB2NGwyX20ybV9pb2N0bF9zdHJlYW1vbiwNCisJLnZpZGlvY19zdHJl YW1vZmYgPSB2NGwyX20ybV9pb2N0bF9zdHJlYW1vZmYsDQorCS52aWRpb2Nfc3Vic2NyaWJlX2V2 ZW50ID0gdjRsMl9jdHJsX3N1YnNjcmliZV9ldmVudCwNCisJLnZpZGlvY191bnN1YnNjcmliZV9l dmVudCA9IHY0bDJfZXZlbnRfdW5zdWJzY3JpYmUsDQorfTsNCisNCitzdGF0aWMgaW50DQorbXRr X2ZkX3F1ZXVlX2luaXQodm9pZCAqcHJpdiwgc3RydWN0IHZiMl9xdWV1ZSAqc3JjX3ZxLA0KKwkJ ICBzdHJ1Y3QgdmIyX3F1ZXVlICpkc3RfdnEpDQorew0KKwlzdHJ1Y3QgbXRrX2ZkX2N0eCAqY3R4 ID0gcHJpdjsNCisJaW50IHJldDsNCisNCisJc3JjX3ZxLT50eXBlID0gVjRMMl9CVUZfVFlQRV9W SURFT19PVVRQVVRfTVBMQU5FOw0KKwlzcmNfdnEtPmlvX21vZGVzID0gVkIyX01NQVAgfCBWQjJf RE1BQlVGOw0KKwlzcmNfdnEtPnN1cHBvcnRzX3JlcXVlc3RzID0gdHJ1ZTsNCisJc3JjX3ZxLT5k cnZfcHJpdiA9IGN0eDsNCisJc3JjX3ZxLT5vcHMgPSAmbXRrX2ZkX3ZiMl9vcHM7DQorCXNyY192 cS0+bWVtX29wcyA9ICZ2YjJfZG1hX2NvbnRpZ19tZW1vcHM7DQorCXNyY192cS0+YnVmX3N0cnVj dF9zaXplID0gc2l6ZW9mKHN0cnVjdCB2NGwyX20ybV9idWZmZXIpOw0KKwlzcmNfdnEtPnRpbWVz dGFtcF9mbGFncyA9IFY0TDJfQlVGX0ZMQUdfVElNRVNUQU1QX0NPUFk7DQorCXNyY192cS0+bG9j ayA9ICZjdHgtPmZkX2Rldi0+dmZkX2xvY2s7DQorCXNyY192cS0+ZGV2ID0gY3R4LT5mZF9kZXYt PnY0bDJfZGV2LmRldjsNCisNCisJcmV0ID0gdmIyX3F1ZXVlX2luaXQoc3JjX3ZxKTsNCisJaWYg KHJldCkNCisJCXJldHVybiByZXQ7DQorDQorCWRzdF92cS0+dHlwZSA9IFY0TDJfQlVGX1RZUEVf TUVUQV9DQVBUVVJFOw0KKwlkc3RfdnEtPmlvX21vZGVzID0gVkIyX01NQVAgfCBWQjJfRE1BQlVG Ow0KKwlkc3RfdnEtPmRydl9wcml2ID0gY3R4Ow0KKwlkc3RfdnEtPm9wcyA9ICZtdGtfZmRfdmIy X29wczsNCisJZHN0X3ZxLT5tZW1fb3BzID0gJnZiMl9kbWFfY29udGlnX21lbW9wczsNCisJZHN0 X3ZxLT5idWZfc3RydWN0X3NpemUgPSBzaXplb2Yoc3RydWN0IHY0bDJfbTJtX2J1ZmZlcik7DQor CWRzdF92cS0+dGltZXN0YW1wX2ZsYWdzID0gVjRMMl9CVUZfRkxBR19USU1FU1RBTVBfQ09QWTsN CisJZHN0X3ZxLT5sb2NrID0gJmN0eC0+ZmRfZGV2LT52ZmRfbG9jazsNCisJZHN0X3ZxLT5kZXYg PSBjdHgtPmZkX2Rldi0+djRsMl9kZXYuZGV2Ow0KKw0KKwlyZXR1cm4gdmIyX3F1ZXVlX2luaXQo ZHN0X3ZxKTsNCit9DQorDQorc3RhdGljIHN0cnVjdCB2NGwyX2N0cmxfY29uZmlnIG10a19mZF9j b250cm9sc1tdID0gew0KKwl7DQorCQkuaWQgPSBWNEwyX0NJRF9NVEtfRkRfU0NBTEVfRE9XTl9J TUdfV0lEVEgsDQorCQkubmFtZSA9ICJGRCBzY2FsZSBpbWFnZSB3aWR0aHMiLA0KKwkJLnR5cGUg PSBWNEwyX0NUUkxfVFlQRV9VMTYsDQorCQkubWluID0gTVRLX0ZEX09VVFBVVF9NSU5fV0lEVEgs DQorCQkubWF4ID0gTVRLX0ZEX09VVFBVVF9NQVhfV0lEVEgsDQorCQkuc3RlcCA9IDEsDQorCQku ZGVmID0gTVRLX0ZEX09VVFBVVF9NQVhfV0lEVEgsDQorCQkuZGltcyA9IHsgTVRLX0ZEX1NDQUxF X0FSUl9OVU0gfSwNCisJfSwNCisJew0KKwkJLmlkID0gVjRMMl9DSURfTVRLX0ZEX1NDQUxFX0RP V05fSU1HX0hFSUdIVCwNCisJCS5uYW1lID0gIkZEIHNjYWxlIGltYWdlIGhlaWdodHMiLA0KKwkJ LnR5cGUgPSBWNEwyX0NUUkxfVFlQRV9VMTYsDQorCQkubWluID0gTVRLX0ZEX09VVFBVVF9NSU5f SEVJR0hULA0KKwkJLm1heCA9IE1US19GRF9PVVRQVVRfTUFYX0hFSUdIVCwNCisJCS5zdGVwID0g MSwNCisJCS5kZWYgPSBNVEtfRkRfT1VUUFVUX01BWF9IRUlHSFQsDQorCQkuZGltcyA9IHsgTVRL X0ZEX1NDQUxFX0FSUl9OVU0gfSwNCisJfSwNCisJew0KKwkJLmlkID0gVjRMMl9DSURfTVRLX0ZE X1NDQUxFX0lNR19OVU0sDQorCQkubmFtZSA9ICJGRCBzY2FsZSBzaXplIGNvdW50cyIsDQorCQku dHlwZSA9IFY0TDJfQ1RSTF9UWVBFX0lOVEVHRVIsDQorCQkubWluID0gMCwNCisJCS5tYXggPSBN VEtfRkRfU0NBTEVfQVJSX05VTSwNCisJCS5zdGVwID0gMSwNCisJCS5kZWYgPSAwLA0KKwl9LA0K Kwl7DQorCQkuaWQgPSBWNEwyX0NJRF9NVEtfRkRfREVURUNUX1BPU0UsDQorCQkubmFtZSA9ICJG RCBkZXRlY3QgZmFjZSBhbmdsZSBhbmQgZGlyZWN0aW9ucyIsDQorCQkudHlwZSA9IFY0TDJfQ1RS TF9UWVBFX1UxNiwNCisJCS5taW4gPSAwLA0KKwkJLm1heCA9IDB4ZmZmZiwNCisJCS5zdGVwID0g MSwNCisJCS5kZWYgPSAweDNmZiwNCisJCS5kaW1zID0geyBNVEtfRkRfRkFDRV9BTkdMRV9OVU19 LA0KKwl9LA0KKwl7DQorCQkuaWQgPSBWNEwyX0NJRF9NVEtfRkRfREVURUNUX1NQRUVELA0KKwkJ Lm5hbWUgPSAiRkQgZGV0ZWN0aW9uIHNwZWVkdXAiLA0KKwkJLnR5cGUgPSBWNEwyX0NUUkxfVFlQ RV9JTlRFR0VSLA0KKwkJLm1pbiA9IDAsDQorCQkubWF4ID0gTVRLX0ZEX01BWF9TUEVFRFVQLA0K KwkJLnN0ZXAgPSAxLA0KKwkJLmRlZiA9IDAsDQorCX0sDQorCXsNCisJCS5pZCA9IFY0TDJfQ0lE X01US19GRF9ERVRFQ1RJT05fTU9ERUwsDQorCQkubmFtZSA9ICJGRCB1c2UgZXh0cmEgbW9kZWwi LA0KKwkJLnR5cGUgPSBWNEwyX0NUUkxfVFlQRV9CT09MRUFOLA0KKwkJLm1pbiA9IDAsDQorCQku bWF4ID0gMSwNCisJCS5zdGVwID0gMSwNCisJCS5kZWYgPSAwLA0KKwl9LA0KK307DQorDQorc3Rh dGljIGludCBtdGtfZmRfY3RybHNfc2V0dXAoc3RydWN0IG10a19mZF9jdHggKmN0eCkNCit7DQor CXN0cnVjdCB2NGwyX2N0cmxfaGFuZGxlciAqaGRsID0gJmN0eC0+aGRsOw0KKwlpbnQgaTsNCisN CisJdjRsMl9jdHJsX2hhbmRsZXJfaW5pdChoZGwsIFY0TDJfQ0lEX01US19GRF9NQVgpOw0KKwlp ZiAoaGRsLT5lcnJvcikNCisJCXJldHVybiBoZGwtPmVycm9yOw0KKw0KKwlmb3IgKGkgPSAwOyBp IDwgQVJSQVlfU0laRShtdGtfZmRfY29udHJvbHMpOyBpKyspIHsNCisJCXY0bDJfY3RybF9uZXdf Y3VzdG9tKGhkbCwgJm10a19mZF9jb250cm9sc1tpXSwgY3R4KTsNCisJCWlmIChoZGwtPmVycm9y KSB7DQorCQkJdjRsMl9jdHJsX2hhbmRsZXJfZnJlZShoZGwpOw0KKwkJCWRldl9lcnIoY3R4LT5k ZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgY29udHJvbHM6JWQiLCBpKTsNCisJCQlyZXR1cm4gaGRs LT5lcnJvcjsNCisJCX0NCisJfQ0KKw0KKwljdHgtPmZoLmN0cmxfaGFuZGxlciA9ICZjdHgtPmhk bDsNCisJdjRsMl9jdHJsX2hhbmRsZXJfc2V0dXAoaGRsKTsNCisNCisJcmV0dXJuIDA7DQorfQ0K Kw0KK3N0YXRpYyB1bnNpZ25lZCBpbnQgZ2V0X2ZkX2ltZ19mbXQodW5zaWduZWQgaW50IGZvdXJj YykNCit7DQorCXN3aXRjaCAoZm91cmNjKSB7DQorCWNhc2UgVjRMMl9QSVhfRk1UX1ZZVVk6DQor CQlyZXR1cm4gTVRLX0ZEX0hXX0ZNVF9WWVVZOw0KKwljYXNlIFY0TDJfUElYX0ZNVF9ZVVlWOg0K KwkJcmV0dXJuIE1US19GRF9IV19GTVRfWVVZVjsNCisJY2FzZSBWNEwyX1BJWF9GTVRfWVZZVToN CisJCXJldHVybiBNVEtfRkRfSFdfRk1UX1lWWVU7DQorCWNhc2UgVjRMMl9QSVhfRk1UX1VZVlk6 DQorCQlyZXR1cm4gTVRLX0ZEX0hXX0ZNVF9VWVZZOw0KKwljYXNlIFY0TDJfUElYX0ZNVF9OVjE2 TToNCisJCXJldHVybiBNVEtfRkRfSFdfRk1UX1lVVl8yUDsNCisJY2FzZSBWNEwyX1BJWF9GTVRf TlY2MU06DQorCQlyZXR1cm4gTVRLX0ZEX0hXX0ZNVF9ZVlVfMlA7DQorCWRlZmF1bHQ6DQorCQly ZXR1cm4gTVRLX0ZEX0hXX0ZNVF9VTktOT1dOOw0KKwl9DQorfQ0KKw0KK3N0YXRpYyB2b2lkIGlu aXRfY3R4X2ZtdChzdHJ1Y3QgbXRrX2ZkX2N0eCAqY3R4KQ0KK3sNCisJc3RydWN0IHY0bDJfcGl4 X2Zvcm1hdF9tcGxhbmUgKnNyY19mbXQgPSAmY3R4LT5zcmNfZm10Ow0KKwlzdHJ1Y3QgdjRsMl9t ZXRhX2Zvcm1hdCAqZHN0X2ZtdCA9ICZjdHgtPmRzdF9mbXQ7DQorDQorCS8qIEluaXRpYWxpemUg TTJNIHNvdXJjZSBmbXQgKi8NCisJc3JjX2ZtdC0+d2lkdGggPSBNVEtfRkRfT1VUUFVUX01BWF9X SURUSDsNCisJc3JjX2ZtdC0+aGVpZ2h0ID0gTVRLX0ZEX09VVFBVVF9NQVhfSEVJR0hUOw0KKwlt dGtfZmRfZmlsbF9waXhmbXRfbXAoc3JjX2ZtdCwgJm10a19mZF9pbWdfZm10c1swXSk7DQorDQor CS8qIEluaXRpYWxpemUgTTJNIGRlc3RpbmF0aW9uIGZtdCAqLw0KKwlkc3RfZm10LT5idWZmZXJz aXplID0gc2l6ZW9mKHN0cnVjdCBmZF91c2VyX291dHB1dCk7DQorCWRzdF9mbXQtPmRhdGFmb3Jt YXQgPSBWNEwyX01FVEFfRk1UX01URkRfUkVTVUxUOw0KK30NCisNCisvKg0KKyAqIFY0TDIgZmls ZSBvcGVyYXRpb25zLg0KKyAqLw0KK3N0YXRpYyBpbnQgbXRrX3ZmZF9vcGVuKHN0cnVjdCBmaWxl ICpmaWxwKQ0KK3sNCisJc3RydWN0IG10a19mZF9kZXYgKmZkID0gdmlkZW9fZHJ2ZGF0YShmaWxw KTsNCisJc3RydWN0IHZpZGVvX2RldmljZSAqdmRldiA9IHZpZGVvX2RldmRhdGEoZmlscCk7DQor CXN0cnVjdCBtdGtfZmRfY3R4ICpjdHg7DQorCWludCByZXQ7DQorDQorCWN0eCA9IGt6YWxsb2Mo c2l6ZW9mKCpjdHgpLCBHRlBfS0VSTkVMKTsNCisJaWYgKCFjdHgpDQorCQlyZXR1cm4gLUVOT01F TTsNCisNCisJY3R4LT5mZF9kZXYgPSBmZDsNCisJY3R4LT5kZXYgPSBmZC0+ZGV2Ow0KKwlmZC0+ Y3R4ID0gY3R4Ow0KKw0KKwl2NGwyX2ZoX2luaXQoJmN0eC0+ZmgsIHZkZXYpOw0KKwlmaWxwLT5w cml2YXRlX2RhdGEgPSAmY3R4LT5maDsNCisNCisJaW5pdF9jdHhfZm10KGN0eCk7DQorDQorCXJl dCA9IG10a19mZF9jdHJsc19zZXR1cChjdHgpOw0KKwlpZiAocmV0KSB7DQorCQlkZXZfZXJyKGN0 eC0+ZGV2LCAiRmFpbGVkIHRvIHNldCB1cCBjb250cm9sczolZFxuIiwgcmV0KTsNCisJCWdvdG8g ZXJyX2ZoX2V4aXQ7DQorCX0NCisNCisJY3R4LT5maC5tMm1fY3R4ID0gdjRsMl9tMm1fY3R4X2lu aXQoZmQtPm0ybV9kZXYsIGN0eCwNCisJCQkJCSAgICAmbXRrX2ZkX3F1ZXVlX2luaXQpOw0KKwlp ZiAoSVNfRVJSKGN0eC0+ZmgubTJtX2N0eCkpIHsNCisJCXJldCA9IFBUUl9FUlIoY3R4LT5maC5t Mm1fY3R4KTsNCisJCWdvdG8gZXJyX2ZyZWVfY3RybF9oYW5kbGVyOw0KKwl9DQorDQorCXY0bDJf ZmhfYWRkKCZjdHgtPmZoKTsNCisNCisJcmV0dXJuIDA7DQorDQorZXJyX2ZyZWVfY3RybF9oYW5k bGVyOg0KKwl2NGwyX2N0cmxfaGFuZGxlcl9mcmVlKCZjdHgtPmhkbCk7DQorZXJyX2ZoX2V4aXQ6 DQorCXY0bDJfZmhfZXhpdCgmY3R4LT5maCk7DQorCWtmcmVlKGN0eCk7DQorDQorCXJldHVybiBy ZXQ7DQorfQ0KKw0KK3N0YXRpYyBpbnQgbXRrX3ZmZF9yZWxlYXNlKHN0cnVjdCBmaWxlICpmaWxw KQ0KK3sNCisJc3RydWN0IG10a19mZF9jdHggKmN0eCA9IGNvbnRhaW5lcl9vZihmaWxwLT5wcml2 YXRlX2RhdGEsDQorCQkJCQkgICAgICBzdHJ1Y3QgbXRrX2ZkX2N0eCwgZmgpOw0KKw0KKwl2NGwy X20ybV9jdHhfcmVsZWFzZShjdHgtPmZoLm0ybV9jdHgpOw0KKw0KKwl2NGwyX2N0cmxfaGFuZGxl cl9mcmVlKCZjdHgtPmhkbCk7DQorCXY0bDJfZmhfZGVsKCZjdHgtPmZoKTsNCisJdjRsMl9maF9l eGl0KCZjdHgtPmZoKTsNCisNCisJa2ZyZWUoY3R4KTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0K K3N0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9maWxlX29wZXJhdGlvbnMgZmRfdmlkZW9fZm9wcyA9 IHsNCisJLm93bmVyID0gVEhJU19NT0RVTEUsDQorCS5vcGVuID0gbXRrX3ZmZF9vcGVuLA0KKwku cmVsZWFzZSA9IG10a192ZmRfcmVsZWFzZSwNCisJLnBvbGwgPSB2NGwyX20ybV9mb3BfcG9sbCwN CisJLnVubG9ja2VkX2lvY3RsID0gdmlkZW9faW9jdGwyLA0KKwkubW1hcCA9IHY0bDJfbTJtX2Zv cF9tbWFwLA0KKyNpZmRlZiBDT05GSUdfQ09NUEFUDQorCS5jb21wYXRfaW9jdGwzMiA9IHY0bDJf Y29tcGF0X2lvY3RsMzIsDQorI2VuZGlmDQorDQorfTsNCisNCitzdGF0aWMgdm9pZCBtdGtfZmRf ZmlsbF91c2VyX3BhcmFtKHN0cnVjdCB1c2VyX3BhcmFtICp1c2VyX3BhcmFtLA0KKwkJCQkgICBz dHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXIgKmhkbCkNCit7DQorCXN0cnVjdCB2NGwyX2N0cmwgKmN0 cmw7DQorCWludCBpOw0KKw0KKwljdHJsID0gdjRsMl9jdHJsX2ZpbmQoaGRsLCBWNEwyX0NJRF9N VEtfRkRfU0NBTEVfRE9XTl9JTUdfV0lEVEgpOw0KKwlpZiAoY3RybCkNCisJCWZvciAoaSA9IDA7 IGkgPCBjdHJsLT5lbGVtczsgaSsrKQ0KKwkJCXVzZXJfcGFyYW0tPnNjYWxlX2ltZ193aWR0aFtp XSA9IGN0cmwtPnBfbmV3LnBfdTE2W2ldOw0KKwljdHJsID0gdjRsMl9jdHJsX2ZpbmQoaGRsLCBW NEwyX0NJRF9NVEtfRkRfU0NBTEVfRE9XTl9JTUdfSEVJR0hUKTsNCisJaWYgKGN0cmwpDQorCQlm b3IgKGkgPSAwOyBpIDwgY3RybC0+ZWxlbXM7IGkrKykNCisJCQl1c2VyX3BhcmFtLT5zY2FsZV9p bWdfaGVpZ2h0W2ldID0gY3RybC0+cF9uZXcucF91MTZbaV07DQorCWN0cmwgPSB2NGwyX2N0cmxf ZmluZChoZGwsIFY0TDJfQ0lEX01US19GRF9TQ0FMRV9JTUdfTlVNKTsNCisJaWYgKGN0cmwpDQor CQl1c2VyX3BhcmFtLT5zY2FsZV9pbWdfbnVtID0gY3RybC0+dmFsOw0KKw0KKwljdHJsID0gdjRs Ml9jdHJsX2ZpbmQoaGRsLCBWNEwyX0NJRF9NVEtfRkRfREVURUNUX1BPU0UpOw0KKwlpZiAoY3Ry bCkNCisJCWZvciAoaSA9IDA7IGkgPCBjdHJsLT5lbGVtczsgaSsrKQ0KKwkJCXVzZXJfcGFyYW0t PmZhY2VfZGlyZWN0aW9uc1tpXSA9IGN0cmwtPnBfbmV3LnBfdTE2W2ldOw0KKwljdHJsID0gdjRs Ml9jdHJsX2ZpbmQoaGRsLCBWNEwyX0NJRF9NVEtfRkRfREVURUNUX1NQRUVEKTsNCisJaWYgKGN0 cmwpDQorCQl1c2VyX3BhcmFtLT5mZF9zcGVlZHVwID0gY3RybC0+dmFsOw0KKwljdHJsID0gdjRs Ml9jdHJsX2ZpbmQoaGRsLCBWNEwyX0NJRF9NVEtfRkRfREVURUNUSU9OX01PREVMKTsNCisJaWYg KGN0cmwpDQorCQl1c2VyX3BhcmFtLT5mZF9leHRyYV9tb2RlbCA9IGN0cmwtPnZhbDsNCit9DQor DQorc3RhdGljIHZvaWQgbXRrX2ZkX2RldmljZV9ydW4odm9pZCAqcHJpdikNCit7DQorCXN0cnVj dCBtdGtfZmRfY3R4ICpjdHggPSBwcml2Ow0KKwlzdHJ1Y3QgbXRrX2ZkX2RldiAqZmQgPSBjdHgt PmZkX2RldjsNCisJc3RydWN0IHZiMl92NGwyX2J1ZmZlciAqc3JjX2J1ZiwgKmRzdF9idWY7DQor CXN0cnVjdCBmZF9lbnFfcGFyYW0gZmRfcGFyYW07DQorCXZvaWQgKnBsYW5lX3ZhZGRyOw0KKw0K KwlzcmNfYnVmID0gdjRsMl9tMm1fbmV4dF9zcmNfYnVmKGN0eC0+ZmgubTJtX2N0eCk7DQorCWRz dF9idWYgPSB2NGwyX20ybV9uZXh0X2RzdF9idWYoY3R4LT5maC5tMm1fY3R4KTsNCisNCisJZmRf cGFyYW0uc3JjX2ltZ1swXS5kbWFfYWRkciA9DQorCQl2YjJfZG1hX2NvbnRpZ19wbGFuZV9kbWFf YWRkcigmc3JjX2J1Zi0+dmIyX2J1ZiwgMCk7DQorCWZkX3BhcmFtLnVzZXJfcmVzdWx0LmRtYV9h ZGRyID0NCisJCXZiMl9kbWFfY29udGlnX3BsYW5lX2RtYV9hZGRyKCZkc3RfYnVmLT52YjJfYnVm LCAwKTsNCisJcGxhbmVfdmFkZHIgPSB2YjJfcGxhbmVfdmFkZHIoJmRzdF9idWYtPnZiMl9idWYs IDApOw0KKwlmZF9wYXJhbS5vdXRwdXRfdmFkZHIgPSAodTY0KSh1bnNpZ25lZCBsb25nKXBsYW5l X3ZhZGRyOw0KKwlmZF9wYXJhbS51c2VyX3BhcmFtLnNyY19pbWdfZm10ID0NCisJCWdldF9mZF9p bWdfZm10KGN0eC0+c3JjX2ZtdC5waXhlbGZvcm1hdCk7DQorCWlmIChjdHgtPnNyY19mbXQubnVt X3BsYW5lcyA9PSAyKQ0KKwkJZmRfcGFyYW0uc3JjX2ltZ1sxXS5kbWFfYWRkciA9DQorCQkJdmIy X2RtYV9jb250aWdfcGxhbmVfZG1hX2FkZHIoJnNyY19idWYtPnZiMl9idWYsIDEpOw0KKwltdGtf ZmRfZmlsbF91c2VyX3BhcmFtKCZmZF9wYXJhbS51c2VyX3BhcmFtLCAmY3R4LT5oZGwpOw0KKw0K KwkvKiBDb21wbGV0ZSByZXF1ZXN0IGNvbnRyb2xzIGlmIGFueSAqLw0KKwl2NGwyX2N0cmxfcmVx dWVzdF9jb21wbGV0ZShzcmNfYnVmLT52YjJfYnVmLnJlcV9vYmoucmVxLCAmY3R4LT5oZGwpOw0K Kw0KKwlmZC0+b3V0cHV0ID0gcGxhbmVfdmFkZHI7DQorCW10a19mZF9od19qb2JfZXhlYyhmZCwg JmZkX3BhcmFtKTsNCit9DQorDQorc3RhdGljIHN0cnVjdCB2NGwyX20ybV9vcHMgZmRfbTJtX29w cyA9IHsNCisJLmRldmljZV9ydW4gPSBtdGtfZmRfZGV2aWNlX3J1biwNCit9Ow0KKw0KK3N0YXRp YyBjb25zdCBzdHJ1Y3QgbWVkaWFfZGV2aWNlX29wcyBmZF9tMm1fbWVkaWFfb3BzID0gew0KKwku cmVxX3ZhbGlkYXRlCT0gdmIyX3JlcXVlc3RfdmFsaWRhdGUsDQorCS5yZXFfcXVldWUJPSB2NGwy X20ybV9yZXF1ZXN0X3F1ZXVlLA0KK307DQorDQorc3RhdGljIGludCBtdGtfZmRfdmlkZW9fZGV2 aWNlX3JlZ2lzdGVyKHN0cnVjdCBtdGtfZmRfZGV2ICpmZCkNCit7DQorCXN0cnVjdCB2aWRlb19k ZXZpY2UgKnZmZCA9ICZmZC0+dmZkOw0KKwlzdHJ1Y3QgdjRsMl9tMm1fZGV2ICptMm1fZGV2ID0g ZmQtPm0ybV9kZXY7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9IGZkLT5kZXY7DQorCWludCByZXQ7 DQorDQorCXZmZC0+Zm9wcyA9ICZmZF92aWRlb19mb3BzOw0KKwl2ZmQtPnJlbGVhc2UgPSB2aWRl b19kZXZpY2VfcmVsZWFzZTsNCisJdmZkLT5sb2NrID0gJmZkLT52ZmRfbG9jazsNCisJdmZkLT52 NGwyX2RldiA9ICZmZC0+djRsMl9kZXY7DQorCXZmZC0+dmZsX2RpciA9IFZGTF9ESVJfTTJNOw0K Kwl2ZmQtPmRldmljZV9jYXBzID0gVjRMMl9DQVBfU1RSRUFNSU5HIHwgVjRMMl9DQVBfVklERU9f T1VUUFVUX01QTEFORSB8DQorCQlWNEwyX0NBUF9NRVRBX0NBUFRVUkU7DQorCXZmZC0+aW9jdGxf b3BzID0gJm10a19mZF92NGwyX3ZpZGVvX291dF9pb2N0bF9vcHM7DQorDQorCXN0cnNjcHkodmZk LT5uYW1lLCBkZXZfZHJpdmVyX3N0cmluZyhkZXYpLCBzaXplb2YodmZkLT5uYW1lKSk7DQorDQor CXZpZGVvX3NldF9kcnZkYXRhKHZmZCwgZmQpOw0KKw0KKwlyZXQgPSB2aWRlb19yZWdpc3Rlcl9k ZXZpY2UodmZkLCBWRkxfVFlQRV9HUkFCQkVSLCAwKTsNCisJaWYgKHJldCkgew0KKwkJZGV2X2Vy cihkZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgdmlkZW8gZGV2aWNlXG4iKTsNCisJCWdvdG8gZXJy X2ZyZWVfZGV2Ow0KKwl9DQorDQorCXJldCA9IHY0bDJfbTJtX3JlZ2lzdGVyX21lZGlhX2NvbnRy b2xsZXIobTJtX2RldiwgdmZkLA0KKwkJCQkJICAgICBNRURJQV9FTlRfRl9QUk9DX1ZJREVPX1NU QVRJU1RJQ1MpOw0KKwlpZiAocmV0KSB7DQorCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byBpbml0 IG1lbTJtZW0gbWVkaWEgY29udHJvbGxlclxuIik7DQorCQlnb3RvIGVycl91bnJlZ192aWRlbzsN CisJfQ0KKwlyZXR1cm4gMDsNCisNCitlcnJfdW5yZWdfdmlkZW86DQorCXZpZGVvX3VucmVnaXN0 ZXJfZGV2aWNlKHZmZCk7DQorZXJyX2ZyZWVfZGV2Og0KKwl2aWRlb19kZXZpY2VfcmVsZWFzZSh2 ZmQpOw0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCitzdGF0aWMgaW50IG10a19mZF9kZXZfdjRsMl9p bml0KHN0cnVjdCBtdGtfZmRfZGV2ICpmZCkNCit7DQorCXN0cnVjdCBtZWRpYV9kZXZpY2UgKm1k ZXYgPSAmZmQtPm1kZXY7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9IGZkLT5kZXY7DQorCWludCBy ZXQ7DQorDQorCXJldCA9IHY0bDJfZGV2aWNlX3JlZ2lzdGVyKGRldiwgJmZkLT52NGwyX2Rldik7 DQorCWlmIChyZXQpIHsNCisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIHJlZ2lzdGVyIHY0bDIg ZGV2aWNlXG4iKTsNCisJCXJldHVybiByZXQ7DQorCX0NCisNCisJZmQtPm0ybV9kZXYgPSB2NGwy X20ybV9pbml0KCZmZF9tMm1fb3BzKTsNCisJaWYgKElTX0VSUihmZC0+bTJtX2RldikpIHsNCisJ CWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGluaXQgbWVtMm1lbSBkZXZpY2VcbiIpOw0KKwkJcmV0 ID0gUFRSX0VSUihmZC0+bTJtX2Rldik7DQorCQlnb3RvIGVycl91bnJlZ192NGwyX2RldjsNCisJ fQ0KKw0KKwltZGV2LT5kZXYgPSBkZXY7DQorCXN0cnNjcHkobWRldi0+bW9kZWwsIGRldl9kcml2 ZXJfc3RyaW5nKGRldiksIHNpemVvZihtZGV2LT5tb2RlbCkpOw0KKwlzbnByaW50ZihtZGV2LT5i dXNfaW5mbywgc2l6ZW9mKG1kZXYtPmJ1c19pbmZvKSwNCisJCSAicGxhdGZvcm06JXMiLCBkZXZf bmFtZShkZXYpKTsNCisJbWVkaWFfZGV2aWNlX2luaXQobWRldik7DQorCW1kZXYtPm9wcyA9ICZm ZF9tMm1fbWVkaWFfb3BzOw0KKwlmZC0+djRsMl9kZXYubWRldiA9IG1kZXY7DQorDQorCXJldCA9 IG10a19mZF92aWRlb19kZXZpY2VfcmVnaXN0ZXIoZmQpOw0KKwlpZiAocmV0KSB7DQorCQlkZXZf ZXJyKGRldiwgIkZhaWxlZCB0byByZWdpc3RlciB2aWRlbyBkZXZpY2VcbiIpOw0KKwkJZ290byBl cnJfY2xlYW51cF9tZGV2Ow0KKwl9DQorDQorCXJldCA9IG1lZGlhX2RldmljZV9yZWdpc3Rlciht ZGV2KTsNCisJaWYgKHJldCkgew0KKwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIg bWVtMm1lbSBtZWRpYSBkZXZpY2VcbiIpOw0KKwkJZ290byBlcnJfdW5yZWdfdmRldjsNCisJfQ0K Kw0KKwlyZXR1cm4gMDsNCisNCitlcnJfdW5yZWdfdmRldjoNCisJdjRsMl9tMm1fdW5yZWdpc3Rl cl9tZWRpYV9jb250cm9sbGVyKGZkLT5tMm1fZGV2KTsNCisJdmlkZW9fdW5yZWdpc3Rlcl9kZXZp Y2UoJmZkLT52ZmQpOw0KKwl2aWRlb19kZXZpY2VfcmVsZWFzZSgmZmQtPnZmZCk7DQorZXJyX2Ns ZWFudXBfbWRldjoNCisJbWVkaWFfZGV2aWNlX2NsZWFudXAobWRldik7DQorCXY0bDJfbTJtX3Jl bGVhc2UoZmQtPm0ybV9kZXYpOw0KK2Vycl91bnJlZ192NGwyX2RldjoNCisJdjRsMl9kZXZpY2Vf dW5yZWdpc3RlcigmZmQtPnY0bDJfZGV2KTsNCisJcmV0dXJuIHJldDsNCit9DQorDQorc3RhdGlj IHZvaWQgbXRrX2ZkX2Rldl92NGwyX3JlbGVhc2Uoc3RydWN0IG10a19mZF9kZXYgKmZkKQ0KK3sN CisJdjRsMl9tMm1fdW5yZWdpc3Rlcl9tZWRpYV9jb250cm9sbGVyKGZkLT5tMm1fZGV2KTsNCisJ dmlkZW9fdW5yZWdpc3Rlcl9kZXZpY2UoJmZkLT52ZmQpOw0KKwl2aWRlb19kZXZpY2VfcmVsZWFz ZSgmZmQtPnZmZCk7DQorCW1lZGlhX2RldmljZV9jbGVhbnVwKCZmZC0+bWRldik7DQorCXY0bDJf bTJtX3JlbGVhc2UoZmQtPm0ybV9kZXYpOw0KKwl2NGwyX2RldmljZV91bnJlZ2lzdGVyKCZmZC0+ djRsMl9kZXYpOw0KK30NCisNCitzdGF0aWMgaXJxcmV0dXJuX3QgbXRrX2ZkX2lycShpbnQgaXJx LCB2b2lkICpkYXRhKQ0KK3sNCisJc3RydWN0IG10a19mZF9kZXYgKmZkID0gKHN0cnVjdCBtdGtf ZmRfZGV2ICopZGF0YTsNCisNCisJLyogbXVzdCByZWFkIHRoaXMgcmVnaXN0ZXIgb3RoZXJ3aXNl IEhXIHdpbGwga2VlcCBzZW5kaW5nIGlycSAqLw0KKwlyZWFkbChmZC0+ZmRfYmFzZSArIE1US19G RF9SRUdfT0ZGU0VUX0lOVF9WQUwpOw0KKwlmZC0+b3V0cHV0LT5udW1iZXIgPSByZWFkbChmZC0+ ZmRfYmFzZSArIE1US19GRF9SRUdfT0ZGU0VUX1JFU1VMVCk7DQorCWRldl9kYmcoZmQtPmRldiwg Im10a19mZF9mYWNlX251bTolZFxuIiwgZmQtPm91dHB1dC0+bnVtYmVyKTsNCisNCisJbXRrX2Zk X2h3X2RvbmUoZmQsIFZCMl9CVUZfU1RBVEVfRE9ORSk7DQorCXJldHVybiBJUlFfSEFORExFRDsN Cit9DQorDQorc3RhdGljIGludCBtdGtfZmRfaHdfZ2V0X3NjcF9tZW0oc3RydWN0IG10a19mZF9k ZXYgKmZkKQ0KK3sNCisJc3RydWN0IGRldmljZSAqZGV2ID0gZmQtPmRldjsNCisJZG1hX2FkZHJf dCBhZGRyOw0KKwl2b2lkICpwdHI7DQorCXUzMiByZXQ7DQorDQorCS8qDQorCSAqIEFsbG9jYXRl IGNvaGVyZW50IHJlc2VydmVkIG1lbW9yeSBmb3IgU0NQIGZpcm13YXJlIHVzYWdlLg0KKwkgKiBU aGUgc2l6ZSBvZiBTQ1AgY29tcG9zZXIncyBtZW1vcnkgaXMgZml4ZWQgdG8gMHgxMDAwMDANCisJ ICogZm9yIHRoZSByZXF1aXJlbWVudCBvZiBmaXJtd2FyZS4NCisJICovDQorCXB0ciA9IGRtYV9h bGxvY19jb2hlcmVudCgmZmQtPnNjcF9wZGV2LT5kZXYsDQorCQkJCSBNVEtfRkRfSFdfV09SS19C VUZfU0laRSwgJmFkZHIsIEdGUF9LRVJORUwpOw0KKwlpZiAoIXB0cikNCisJCXJldHVybiAtRU5P TUVNOw0KKw0KKwlmZC0+c2NwX21lbS5zY3BfYWRkciA9IGFkZHI7DQorCWZkLT5zY3BfbWVtX3Zp cnRfYWRkciA9IHB0cjsNCisJZGV2X2luZm8oZGV2LCAic2NwIGFkZHI6JXBhZCB2YTolcEtcbiIs ICZhZGRyLCBwdHIpOw0KKw0KKwkvKg0KKwkgKiBUaGlzIHJlc2VydmVkIG1lbW9yeSBpcyBhbHNv IGJlIHVzZWQgYnkgRkQgSFcuDQorCSAqIE5lZWQgdG8gZ2V0IGlvdmEgYWRkcmVzcyBmb3IgRkQg RE1BLg0KKwkgKi8NCisJYWRkciA9IGRtYV9tYXBfcmVzb3VyY2UoZGV2LCBhZGRyLCBNVEtfRkRf SFdfV09SS19CVUZfU0laRSwNCisJCQkJRE1BX1RPX0RFVklDRSwgRE1BX0FUVFJfU0tJUF9DUFVf U1lOQyk7DQorCWlmIChkbWFfbWFwcGluZ19lcnJvcihkZXYsIGFkZHIpKSB7DQorCQlkZXZfZXJy KGRldiwgIkZhaWxlZCB0byBtYXAgc2NwIGlvdmFcbiIpOw0KKwkJcmV0ID0gLUVOT01FTTsNCisJ CWdvdG8gZmFpbF9mcmVlX21lbTsNCisJfQ0KKwlmZC0+c2NwX21lbS5kbWFfYWRkciA9IGFkZHI7 DQorCWRldl9pbmZvKGRldiwgInNjcCBpb3ZhIGFkZHI6JXBhZFxuIiwgJmFkZHIpOw0KKw0KKwly ZXR1cm4gMDsNCisNCitmYWlsX2ZyZWVfbWVtOg0KKwlkbWFfZnJlZV9jb2hlcmVudCgmZmQtPnNj cF9wZGV2LT5kZXYsIE1US19GRF9IV19XT1JLX0JVRl9TSVpFLA0KKwkJCSAgcHRyLCBmZC0+c2Nw X21lbS5zY3BfYWRkcik7DQorCWZkLT5zY3BfbWVtLnNjcF9hZGRyID0gMDsNCisNCisJcmV0dXJu IHJldDsNCit9DQorDQorc3RhdGljIGludCBtdGtfZmRfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikNCit7DQorCXN0cnVjdCBtdGtfZmRfZGV2ICpmZDsNCisJc3RydWN0IGRldmlj ZSAqZGV2ID0gJnBkZXYtPmRldjsNCisNCisJc3RydWN0IHJlc291cmNlICpyZXM7DQorCXBoYW5k bGUgcnByb2NfcGhhbmRsZTsNCisJaW50IGlycTsNCisJaW50IHJldDsNCisNCisJZmQgPSBkZXZt X2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpmZCksIEdGUF9LRVJORUwpOw0KKwlpZiAoIWZk KQ0KKwkJcmV0dXJuIC1FTk9NRU07DQorDQorCWRldl9zZXRfZHJ2ZGF0YShkZXYsIGZkKTsNCisJ ZmQtPmRldiA9IGRldjsNCisNCisJaXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCisJ aWYgKGlycSA8IDApIHsNCisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGdldCBpcnEgYnkgcGxh dGZvcm06ICVkXG4iLCBpcnEpOw0KKwkJcmV0dXJuIGlycTsNCisJfQ0KKwlyZXQgPSBkZXZtX3Jl cXVlc3RfaXJxKGRldiwgaXJxLCBtdGtfZmRfaXJxLCBJUlFGX1NIQVJFRCwNCisJCQkgICAgICAg ZGV2X2RyaXZlcl9zdHJpbmcoZGV2KSwNCisJCQkgICAgICAgZmQpOw0KKwlpZiAocmV0KSB7DQor CQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byByZXF1ZXN0IGlycVxuIik7DQorCQlyZXR1cm4gcmV0 Ow0KKwl9DQorDQorCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNF X01FTSwgMCk7DQorCWZkLT5mZF9iYXNlID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKGRldiwgcmVz KTsNCisJaWYgKElTX0VSUihmZC0+ZmRfYmFzZSkpIHsNCisJCWRldl9lcnIoZGV2LCAiRmFpbGVk IHRvIGdldCBmZCByZWcgYmFzZVxuIik7DQorCQlyZXR1cm4gUFRSX0VSUihmZC0+ZmRfYmFzZSk7 DQorCX0NCisNCisJZmQtPmZkX2NsayA9IGRldm1fY2xrX2dldChkZXYsICJmZCIpOw0KKwlpZiAo SVNfRVJSKGZkLT5mZF9jbGspKSB7DQorCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byBnZXQgZmRf Y2xrX2ltZ19mZCBjbG9ja1xuIik7DQorCQlyZXR1cm4gUFRSX0VSUihmZC0+ZmRfY2xrKTsNCisJ fQ0KKw0KKwkvKiBpbml0IHNjcCAqLw0KKwlmZC0+c2NwX3BkZXYgPSBzY3BfZ2V0X3BkZXYocGRl dik7DQorCWlmICghZmQtPnNjcF9wZGV2KSB7DQorCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byBn ZXQgc2NwIGRldmljZVxuIik7DQorCQlyZXR1cm4gLUVOT0RFVjsNCisJfQ0KKw0KKwlpZiAob2Zf cHJvcGVydHlfcmVhZF91MzIoZmQtPmRldi0+b2Zfbm9kZSwgIm1lZGlhdGVrLHNjcCIsDQorCQkJ CSAmcnByb2NfcGhhbmRsZSkpIHsNCisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGdldCBzY3Ag ZGV2aWNlXG4iKTsNCisJCXJldHVybiAtRUlOVkFMOw0KKwl9DQorDQorCWZkLT5ycHJvY19oYW5k bGUgPSBycHJvY19nZXRfYnlfcGhhbmRsZShycHJvY19waGFuZGxlKTsNCisJaWYgKCFmZC0+cnBy b2NfaGFuZGxlKSB7DQorCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byBnZXQgRkQncyBycHJvY19o YW5kbGVcbiIpOw0KKwkJcmV0dXJuIC1FSU5WQUw7DQorCX0NCisNCisJcmV0ID0gbXRrX2ZkX2h3 X2dldF9zY3BfbWVtKGZkKTsNCisJaWYgKHJldCkgew0KKwkJZGV2X2VycihkZXYsICJGYWlsZWQg dG8gaW5pdCBzY3AgbWVtb3J5OiAlZFxuIiwgcmV0KTsNCisJCXJldHVybiByZXQ7DQorCX0NCisN CisJcmV0ID0gbXRrX2ZkX2h3X2FsbG9jX3JzX2RtYV9hZGRyKGZkKTsNCisJaWYgKHJldCkgew0K KwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gYWxsb2NhdGUgZG1hIGJ1ZmZlcjogJWRcbiIsIHJl dCk7DQorCQlyZXR1cm4gcmV0Ow0KKwl9DQorDQorCW11dGV4X2luaXQoJmZkLT52ZmRfbG9jayk7 DQorCWluaXRfY29tcGxldGlvbigmZmQtPmZkX2pvYl9maW5pc2hlZCk7DQorCUlOSVRfREVMQVlF RF9XT1JLKCZmZC0+am9iX3RpbWVvdXRfd29yaywgbXRrX2ZkX2pvYl90aW1lb3V0X3dvcmspOw0K KwlwbV9ydW50aW1lX2VuYWJsZShkZXYpOw0KKw0KKwlyZXQgPSBtdGtfZmRfZGV2X3Y0bDJfaW5p dChmZCk7DQorCWlmIChyZXQpIHsNCisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGluaXQgdjRs MiBkZXZpY2U6ICVkXG4iLCByZXQpOw0KKwkJZ290byBlcnJfZGVzdHJveV9tdXRleDsNCisJfQ0K Kw0KKwlyZXR1cm4gMDsNCisNCitlcnJfZGVzdHJveV9tdXRleDoNCisJbXV0ZXhfZGVzdHJveSgm ZmQtPnZmZF9sb2NrKTsNCisJcG1fcnVudGltZV9kaXNhYmxlKGZkLT5kZXYpOw0KKwltdGtfZmRf ZnJlZV9kbWFfaGFuZGxlKGZkKTsNCisJcmV0dXJuIHJldDsNCit9DQorDQorc3RhdGljIGludCBt dGtfZmRfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQorew0KKwlzdHJ1Y3Qg bXRrX2ZkX2RldiAqZmQgPSBkZXZfZ2V0X2RydmRhdGEoJnBkZXYtPmRldik7DQorDQorCW10a19m ZF9kZXZfdjRsMl9yZWxlYXNlKGZkKTsNCisJcG1fcnVudGltZV9kaXNhYmxlKCZwZGV2LT5kZXYp Ow0KKwlkbWFfdW5tYXBfcGFnZV9hdHRycyhmZC0+ZGV2LA0KKwkJCSAgICAgZmQtPnNjcF9tZW0u ZG1hX2FkZHIsDQorCQkJICAgICBNVEtfRkRfSFdfV09SS19CVUZfU0laRSwNCisJCQkgICAgIERN QV9UT19ERVZJQ0UsDQorCQkJICAgICBETUFfQVRUUl9TS0lQX0NQVV9TWU5DKTsNCisJZG1hX2Zy ZWVfY29oZXJlbnQoJmZkLT5zY3BfcGRldi0+ZGV2LA0KKwkJCSAgTVRLX0ZEX0hXX1dPUktfQlVG X1NJWkUsDQorCQkJICBmZC0+c2NwX21lbV92aXJ0X2FkZHIsDQorCQkJICBmZC0+c2NwX21lbS5z Y3BfYWRkcik7DQorCW11dGV4X2Rlc3Ryb3koJmZkLT52ZmRfbG9jayk7DQorCW10a19mZF9mcmVl X2RtYV9oYW5kbGUoZmQpOw0KKwlycHJvY19wdXQoZmQtPnJwcm9jX2hhbmRsZSk7DQorDQorCXJl dHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50IG10a19mZF9zdXNwZW5kKHN0cnVjdCBkZXZpY2Ug KmRldikNCit7DQorCXN0cnVjdCBtdGtfZmRfZGV2ICpmZCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYp Ow0KKw0KKwlpZiAocG1fcnVudGltZV9zdXNwZW5kZWQoZGV2KSkNCisJCXJldHVybiAwOw0KKw0K Kwl2NGwyX20ybV9zdXNwZW5kKGZkLT5tMm1fZGV2KTsNCisNCisJLyogc3VzcGVuZCBGRCBIVyAq Lw0KKwl3cml0ZWwoMHgwLCBmZC0+ZmRfYmFzZSArIE1US19GRF9SRUdfT0ZGU0VUX0lOVF9FTik7 DQorCXdyaXRlbCgweDAsIGZkLT5mZF9iYXNlICsgTVRLX0ZEX1JFR19PRkZTRVRfSFdfRU5BQkxF KTsNCisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGZkLT5mZF9jbGspOw0KKwlkZXZfZGJnKGRldiwg IiVzOmRpc2FibGUgY2xvY2tcbiIsIF9fZnVuY19fKTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0K K3N0YXRpYyBpbnQgbXRrX2ZkX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpDQorew0KKwlzdHJ1 Y3QgbXRrX2ZkX2RldiAqZmQgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsNCisJaW50IHJldDsNCisN CisJaWYgKHBtX3J1bnRpbWVfc3VzcGVuZGVkKGRldikpDQorCQlyZXR1cm4gMDsNCisNCisJcmV0 ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGZkLT5mZF9jbGspOw0KKwlpZiAocmV0IDwgMCkgew0KKwkJ ZGV2X2RiZyhkZXYsICJGYWlsZWQgdG8gb3BlbiBmZCBjbGs6JWRcbiIsIHJldCk7DQorCQlyZXR1 cm4gcmV0Ow0KKwl9DQorDQorCS8qIHJlc3VtZSBGRCBIVyAqLw0KKwl3cml0ZWwoTVRLX0ZEX1NF VF9IV19FTkFCTEUsIGZkLT5mZF9iYXNlICsgTVRLX0ZEX1JFR19PRkZTRVRfSFdfRU5BQkxFKTsN CisJd3JpdGVsKDB4MSwgZmQtPmZkX2Jhc2UgKyBNVEtfRkRfUkVHX09GRlNFVF9JTlRfRU4pOw0K KwlkZXZfZGJnKGRldiwgIiVzOmVuYWJsZSBjbG9ja1xuIiwgX19mdW5jX18pOw0KKw0KKwl2NGwy X20ybV9yZXN1bWUoZmQtPm0ybV9kZXYpOw0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGlj IGludCBtdGtfZmRfcnVudGltZV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikNCit7DQorCXN0 cnVjdCBtdGtfZmRfZGV2ICpmZCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOw0KKw0KKwljbGtfZGlz YWJsZV91bnByZXBhcmUoZmQtPmZkX2Nsayk7DQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMg aW50IG10a19mZF9ydW50aW1lX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpDQorew0KKwlzdHJ1 Y3QgbXRrX2ZkX2RldiAqZmQgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsNCisJaW50IHJldDsNCisN CisJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGZkLT5mZF9jbGspOw0KKwlpZiAocmV0IDwgMCkg ew0KKwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gb3BlbiBmZCBjbGs6JWRcbiIsIHJldCk7DQor CQlyZXR1cm4gcmV0Ow0KKwl9DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgY29uc3Qg c3RydWN0IGRldl9wbV9vcHMgbXRrX2ZkX3BtX29wcyA9IHsNCisJU0VUX1NZU1RFTV9TTEVFUF9Q TV9PUFMobXRrX2ZkX3N1c3BlbmQsIG10a19mZF9yZXN1bWUpDQorCVNFVF9SVU5USU1FX1BNX09Q UyhtdGtfZmRfcnVudGltZV9zdXNwZW5kLCBtdGtfZmRfcnVudGltZV9yZXN1bWUsIE5VTEwpDQor fTsNCisNCitzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBtdGtfZmRfb2ZfaWRzW10g PSB7DQorCXsgLmNvbXBhdGlibGUgPSAibWVkaWF0ZWssbXQ4MTgzLWZkIiwgfSwNCisJe30NCit9 Ow0KK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIG10a19mZF9vZl9pZHMpOw0KKw0KK3N0YXRpYyBz dHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIG10a19mZF9kcml2ZXIgPSB7DQorCS5wcm9iZSAgID0gbXRr X2ZkX3Byb2JlLA0KKwkucmVtb3ZlICA9IG10a19mZF9yZW1vdmUsDQorCS5kcml2ZXIgID0gew0K KwkJLm5hbWUgID0gIm10ay1mZC00LjAiLA0KKwkJLm9mX21hdGNoX3RhYmxlID0gb2ZfbWF0Y2hf cHRyKG10a19mZF9vZl9pZHMpLA0KKwkJLnBtID0gJm10a19mZF9wbV9vcHMsDQorCX0NCit9Ow0K K21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIobXRrX2ZkX2RyaXZlcik7DQorTU9EVUxFX0FVVEhPUigi SmVycnktY2ggQ2hlbiA8amVycnktY2guY2hlbkBtZWRpYXRlay5jb20+Iik7DQorTU9EVUxFX0xJ Q0VOU0UoIkdQTCB2MiIpOw0KK01PRFVMRV9ERVNDUklQVElPTigiTWVkaWF0ZWsgRkQgZHJpdmVy Iik7DQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3Y0bDItY29udHJvbHMuaCBiL2lu Y2x1ZGUvdWFwaS9saW51eC92NGwyLWNvbnRyb2xzLmgNCmluZGV4IDNkY2ZjNjE0OGY5OS4uZWFl ODc2ZWE2ZDBhIDEwMDY0NA0KLS0tIGEvaW5jbHVkZS91YXBpL2xpbnV4L3Y0bDItY29udHJvbHMu aA0KKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L3Y0bDItY29udHJvbHMuaA0KQEAgLTE5Miw2ICsx OTIsMTAgQEAgZW51bSB2NGwyX2NvbG9yZnggew0KICAqIFdlIHJlc2VydmUgMTYgY29udHJvbHMg Zm9yIHRoaXMgZHJpdmVyLiAqLw0KICNkZWZpbmUgVjRMMl9DSURfVVNFUl9JTVhfQkFTRQkJCShW NEwyX0NJRF9VU0VSX0JBU0UgKyAweDEwYjApDQogDQorLyogVGhlIGJhc2UgZm9yIHRoZSBtZWRp YXRlayBGRCBkcml2ZXIgY29udHJvbHMgKi8NCisvKiBXZSByZXNlcnZlIDE2IGNvbnRyb2xzIGZv ciB0aGlzIGRyaXZlci4gKi8NCisjZGVmaW5lIFY0TDJfQ0lEX1VTRVJfTVRLX0ZEX0JBU0UJCShW NEwyX0NJRF9VU0VSX0JBU0UgKyAweDEwZDApDQorDQogLyogTVBFRy1jbGFzcyBjb250cm9sIElE cyAqLw0KIC8qIFRoZSBNUEVHIGNvbnRyb2xzIGFyZSBhcHBsaWNhYmxlIHRvIGFsbCBjb2RlYyBj b250cm9scw0KICAqIGFuZCB0aGUgJ01QRUcnIHBhcnQgb2YgdGhlIGRlZmluZSBpcyBoaXN0b3Jp Y2FsICovDQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oIGIvaW5j bHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oDQppbmRleCBiNTY3MWNlMjcyNGYuLjIwM2U0OWVi YzllOCAxMDA2NDQNCi0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC92aWRlb2RldjIuaA0KKysrIGIv aW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oDQpAQCAtNzIxLDYgKzcyMSw5IEBAIHN0cnVj dCB2NGwyX3BpeF9mb3JtYXQgew0KICNkZWZpbmUgVjRMMl9NRVRBX0ZNVF9VVkMgICAgICAgICB2 NGwyX2ZvdXJjYygnVScsICdWJywgJ0MnLCAnSCcpIC8qIFVWQyBQYXlsb2FkIEhlYWRlciBtZXRh ZGF0YSAqLw0KICNkZWZpbmUgVjRMMl9NRVRBX0ZNVF9ENFhYICAgICAgICB2NGwyX2ZvdXJjYygn RCcsICc0JywgJ1gnLCAnWCcpIC8qIEQ0WFggUGF5bG9hZCBIZWFkZXIgbWV0YWRhdGEgKi8NCiAN CisvKiBWZW5kb3Igc3BlY2lmaWMgLSBNZWRpYXRlayBGYWNlIERldGVjdGlvbiBtZXRhIGJ1ZmZl ciBmb3JtYXQgZm9yIGZpcm13YXJlICovDQorI2RlZmluZSBWNEwyX01FVEFfRk1UX01URkRfUkVT VUxUICB2NGwyX2ZvdXJjYygnTScsICdUJywgJ2YnLCAnZCcpIC8qIEZEIG1ldGEgY2FwdHVyZSBi dWZmZXIgKi8NCisNCiAvKiBwcml2IGZpZWxkIHZhbHVlIHRvIGluZGljYXRlcyB0aGF0IHN1YnNl cXVlbnQgZmllbGRzIGFyZSB2YWxpZC4gKi8NCiAjZGVmaW5lIFY0TDJfUElYX0ZNVF9QUklWX01B R0lDCQkweGZlZWRjYWZlDQogDQotLSANCjIuMTguMA0K