Re: [RFC PATCH V1 6/6] platform: mtk-isp: Add Mediatek DIP driver

[Shik Chen <shik@chromium.org>]

Hi Frederic,

Most reviews are already covered by Tomasz, here are some small missing pieces.
Please see my comments inline.

On Wed, Apr 17, 2019 at 06:45:11PM +0800, Frederic Chen wrote:
> This patch adds the driver of Digital Image Processing (DIP)
> unit in Mediatek ISP system, providing image format
> conversion, resizing, and rotation features.
> 
> 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: Frederic Chen <frederic.chen@mediatek.com>
> ---
>  drivers/media/platform/mtk-isp/Makefile       |   18 +
>  .../media/platform/mtk-isp/isp_50/Makefile    |   17 +
>  .../platform/mtk-isp/isp_50/dip/Makefile      |   32 +
>  .../mtk-isp/isp_50/dip/mtk_dip-ctrl.c         |  124 ++
>  .../platform/mtk-isp/isp_50/dip/mtk_dip-dev.c | 1116 +++++++++++++
>  .../platform/mtk-isp/isp_50/dip/mtk_dip-dev.h |  321 ++++
>  .../platform/mtk-isp/isp_50/dip/mtk_dip-hw.h  |  167 ++
>  .../mtk-isp/isp_50/dip/mtk_dip-smem.c         |  322 ++++
>  .../mtk-isp/isp_50/dip/mtk_dip-smem.h         |   39 +
>  .../platform/mtk-isp/isp_50/dip/mtk_dip-sys.c | 1384 +++++++++++++++++
>  .../mtk-isp/isp_50/dip/mtk_dip-v4l2.c         | 1310 ++++++++++++++++
>  11 files changed, 4850 insertions(+)
>  create mode 100644 drivers/media/platform/mtk-isp/Makefile
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/Makefile
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/Makefile
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-ctrl.c
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.c
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.h
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-hw.h
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-smem.c
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-smem.h
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-sys.c
>  create mode 100644 drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-v4l2.c
> 
> diff --git a/drivers/media/platform/mtk-isp/Makefile b/drivers/media/platform/mtk-isp/Makefile
> new file mode 100644
> index 000000000000..24bc5354e2f6
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/Makefile
> @@ -0,0 +1,18 @@
> +#
> +# Copyright (C) 2018 MediaTek Inc.
> +#
> +# This program is free software: you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License version 2 as
> +# published by the Free Software Foundation.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +# GNU General Public License for more details.
> +#
> +
> +obj-$(CONFIG_VIDEO_MEDIATEK_ISP_COMMON) += common/
> +
> +obj-y += isp_50/
> +
> +obj-$(CONFIG_VIDEO_MEDIATEK_ISP_FD_SUPPORT) += fd/
> diff --git a/drivers/media/platform/mtk-isp/isp_50/Makefile b/drivers/media/platform/mtk-isp/isp_50/Makefile
> new file mode 100644
> index 000000000000..fd0e5bd3c781
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/Makefile
> @@ -0,0 +1,17 @@
> +#
> +# Copyright (C) 2018 MediaTek Inc.
> +#
> +# This program is free software: you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License version 2 as
> +# published by the Free Software Foundation.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +# GNU General Public License for more details.
> +#
> +
> +ifeq ($(CONFIG_VIDEO_MEDIATEK_ISP_DIP_SUPPORT),y)
> +obj-y += dip/
> +endif
> +
> diff --git a/drivers/media/platform/mtk-isp/isp_50/dip/Makefile b/drivers/media/platform/mtk-isp/isp_50/dip/Makefile
> new file mode 100644
> index 000000000000..03137416857b
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/dip/Makefile
> @@ -0,0 +1,32 @@
> +#
> +# Copyright (C) 2018 MediaTek Inc.
> +#
> +# This program is free software: you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License version 2 as
> +# published by the Free Software Foundation.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +# GNU General Public License for more details.
> +#
> +$(info $(srctree))
> +ccflags-y += -I$(srctree)/drivers/media/platform/mtk-mdp3
> +
> +obj-y += mtk_dip-sys.o
> +
> +# To provide alloc context managing memory shared
> +# between CPU and ISP coprocessor
> +mtk_dip_smem-objs := \
> +mtk_dip-smem.o
> +
> +obj-y += mtk_dip_smem.o
> +
> +# Utilits to provide frame-based streaming model

typo? should be Utilities.

> +# with v4l2 user interfaces
> +mtk_dip_util-objs := \
> +mtk_dip-dev.o \
> +mtk_dip-v4l2.o \
> +mtk_dip-ctrl.o \
> +
> +obj-y += mtk_dip_util.o
> diff --git a/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-ctrl.c b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-ctrl.c
> new file mode 100644
> index 000000000000..e35574818120
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-ctrl.c
> @@ -0,0 +1,124 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2018 MediaTek Inc.
> + * Author: Frederic Chen <frederic.chen@mediatek.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/device.h>
> +#include <linux/platform_device.h>
> +#include "mtk_dip-dev.h"
> +
> +static void handle_buf_usage_config(struct v4l2_ctrl *ctrl)
> +{
> +	struct mtk_dip_video_device *node =
> +		container_of(ctrl->handler,
> +			     struct mtk_dip_video_device, ctrl_handler);
> +
> +	if (ctrl->val < MTK_DIP_V4l2_BUF_USAGE_DEFAULT ||
> +	    ctrl->val >= MTK_DIP_V4l2_BUF_USAGE_NONE) {
> +		pr_err("Invalid buffer usage id %d", ctrl->val);
> +		return;
> +	}
> +	node->dev_q.buffer_usage = ctrl->val;
> +}
> +
> +static void handle_buf_rotate_config(struct v4l2_ctrl *ctrl)
> +{
> +	struct mtk_dip_video_device *node =
> +		container_of(ctrl->handler,
> +			     struct mtk_dip_video_device, ctrl_handler);
> +
> +	if (ctrl->val != 0 || ctrl->val != 90 ||
> +	    ctrl->val != 180 || ctrl->val != 270) {

Should we use "and" here instead of "or"?

> +		pr_err("Invalid buffer rotation %d", ctrl->val);
> +		return;
> +	}
> +	node->dev_q.rotation = ctrl->val;
> +}
> +
> +static int mtk_dip_video_device_s_ctrl(struct v4l2_ctrl *ctrl)
> +{
> +	switch (ctrl->id) {
> +	case V4L2_CID_PRIVATE_SET_BUFFER_USAGE:
> +		handle_buf_usage_config(ctrl);
> +		break;
> +	case V4L2_CID_ROTATE:
> +		handle_buf_rotate_config(ctrl);
> +		break;
> +	default:
> +			break;

redundant indentation?

> +	}
> +	return 0;
> +}
> +
> +static const struct v4l2_ctrl_ops mtk_dip_video_device_ctrl_ops = {
> +	.s_ctrl = mtk_dip_video_device_s_ctrl,
> +};
> +
> +static const struct v4l2_ctrl_config mtk_dip_buf_usage_config = {
> +	.ops	= &mtk_dip_video_device_ctrl_ops,
> +	.id	= V4L2_CID_PRIVATE_SET_BUFFER_USAGE,
> +	.name	= "MTK ISP SET BUFFER USAGE",
> +	.type	= V4L2_CTRL_TYPE_INTEGER,
> +	.min	= MTK_DIP_V4l2_BUF_USAGE_DEFAULT,
> +	.max	= MTK_DIP_V4l2_BUF_USAGE_POSTPROC,
> +	.step	= 1,
> +	.def	= MTK_DIP_V4l2_BUF_USAGE_DEFAULT,
> +	.flags	= V4L2_CTRL_FLAG_SLIDER | V4L2_CTRL_FLAG_EXECUTE_ON_WRITE,
> +	};
> +
> +int mtk_dip_ctrl_init(struct mtk_dip_pipe *dip_pipe)
> +{
> +	struct v4l2_ctrl_handler *hdl = &dip_pipe->ctrl_handler;
> +	struct mtk_dip_video_device *node;
> +	int i;
> +	int img_nodes_to_be_init[3] = {
> +		MTK_DIP_VIDEO_NODE_ID_RAW_OUT,
> +		MTK_DIP_VIDEO_NODE_ID_MDP0_CAPTURE,
> +		MTK_DIP_VIDEO_NODE_ID_MDP1_CAPTURE
> +	};
> +
> +	v4l2_ctrl_handler_init(hdl, V4L2_CID_MTK_DIP_MAX);
> +
> +	pr_debug("%s init ctrl: %p\n", __func__, hdl);
> +
> +	if (hdl->error) {
> +		pr_err("Failed in v4l2_ctrl_handler_init\n");
> +		return hdl->error;
> +	}
> +
> +	for (i = 0; i < MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM; i++)
> +		v4l2_ctrl_handler_init(&dip_pipe->nodes[i].ctrl_handler,
> +				       V4L2_CID_MTK_DIP_MAX);
> +
> +	for (i = 0; i < ARRAY_SIZE(img_nodes_to_be_init); i++) {
> +		node = &dip_pipe->nodes[img_nodes_to_be_init[i]];
> +
> +		if (v4l2_ctrl_new_custom(&node->ctrl_handler,
> +					 &mtk_dip_buf_usage_config,
> +					 NULL) == NULL)
> +			dev_err(&dip_pipe->dip_dev->pdev->dev,
> +				"Node(%s) create buf_usage_config ctrl failed:(%d)",
> +				node->desc->name,
> +				node->ctrl_handler.error);
> +
> +		if (v4l2_ctrl_new_std(&dip_pipe->ctrl_handler,
> +				      &mtk_dip_video_device_ctrl_ops,
> +			V4L2_CID_ROTATE, 0, 270, 90, 0)	== NULL)
> +			dev_err(&dip_pipe->dip_dev->pdev->dev,
> +				"Node(%s) create rotate ctrl failed:(%d)",
> +				node->desc->name, node->ctrl_handler.error);
> +	}
> +
> +return 0;

missing indentation?

> +}
> +EXPORT_SYMBOL_GPL(mtk_dip_ctrl_init);
> diff --git a/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.c b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.c
> new file mode 100644
> index 000000000000..9f450dae2820
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.c
> @@ -0,0 +1,1116 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2018 MediaTek Inc.
> + * Author: Frederic Chen <frederic.chen@mediatek.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/platform_device.h>
> +#include <media/videobuf2-dma-contig.h>
> +#include <linux/device.h>
> +#include <linux/platform_device.h>
> +#include <media/videobuf2-dma-contig.h>
> +#include <linux/dma-mapping.h>
> +#include <media/v4l2-event.h>
> +#include "mtk_dip-dev.h"
> +#include "mtk_dip-smem.h"
> +#include "mtk-mdp3-regs.h"
> +#include "mtk-img-ipi.h"
> +
> +int mtk_dip_pipe_init(struct mtk_dip_pipe *dip_pipe,
> +		      struct mtk_dip_dev *dip_dev,
> +		      struct mtk_dip_pipe_desc *setting,
> +		      struct media_device *media_dev,
> +		      struct v4l2_device *v4l2_dev,
> +		      struct mtk_dip_smem_dev *smem_alloc_dev)
> +{
> +	int ret, i;
> +
> +	dip_pipe->dip_dev = dip_dev;
> +	dip_pipe->desc = setting;
> +	dip_pipe->smem_alloc_dev = smem_alloc_dev;
> +
> +	atomic_set(&dip_pipe->pipe_job_sequence, 0);
> +	spin_lock_init(&dip_pipe->job_lock);
> +	mutex_init(&dip_pipe->lock);
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev, "init pipe(%s,%d)\n",
> +		dip_pipe->desc->name,
> +		dip_pipe->desc->id);
> +
> +	dip_pipe->num_nodes = MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM;
> +
> +	for (i = 0; i < MTK_DIP_VIDEO_NODE_ID_OUT_TOTAL_NUM; i++) {
> +		dip_pipe->nodes[i].desc =
> +			&dip_pipe->desc->output_queue_descs[i];
> +		dip_pipe->nodes[i].immutable = 0;
> +		dip_pipe->nodes[i].enabled =
> +			dip_pipe->nodes[i].desc->default_enable;
> +		atomic_set(&dip_pipe->nodes[i].sequence, 0);
> +
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: init node(%s,%d)\n",
> +			dip_pipe->desc->name,
> +			dip_pipe->nodes[i].desc->name, i);
> +	}
> +
> +	for (i = MTK_DIP_VIDEO_NODE_ID_OUT_TOTAL_NUM;
> +	     i < MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM; i++) {
> +		int cap_idx = i - MTK_DIP_VIDEO_NODE_ID_OUT_TOTAL_NUM;
> +
> +		dip_pipe->nodes[i].desc =
> +			&dip_pipe->desc->capture_queue_descs[cap_idx];
> +		dip_pipe->nodes[i].immutable = 0;
> +		dip_pipe->nodes[i].enabled =
> +			dip_pipe->nodes[i].desc->default_enable;
> +		atomic_set(&dip_pipe->nodes[i].sequence, 0);
> +
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: init node(%s,%d)\n",
> +			dip_pipe->desc->name,
> +			dip_pipe->nodes[i].desc->name, i);
> +	}

Can we merge these two for loops and check if i < OUT_TOTAL_NUM inside the loop
to remove some duplicate code?

> +
> +	if (dip_pipe->desc->master >= 0 &&
> +	    dip_pipe->desc->master < MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM) {
> +		dip_pipe->nodes[dip_pipe->desc->master].immutable = 1;
> +		dip_pipe->nodes[dip_pipe->desc->master].enabled = 1;
> +	}
> +
> +	ret = mtk_dip_ctrl_init(dip_pipe);
> +
> +	if (ret) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: failed(%d) to initialize ctrls\n",
> +			dip_pipe->desc->name, ret);
> +		goto failed_ctrl;
> +	}
> +
> +	ret = mtk_dip_pipe_v4l2_register(dip_pipe, media_dev, v4l2_dev);
> +
> +	if (ret) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: failed(%d) to create V4L2 devices\n",
> +			dip_pipe->desc->name, ret);
> +		goto failed_pipe;
> +	}
> +
> +	return 0;
> +
> +failed_ctrl:
> +failed_pipe:
> +	mutex_destroy(&dip_pipe->lock);
> +	return ret;
> +}
> +
> +static int mtk_dip_pipe_next_job_id(struct mtk_dip_pipe *dip_pipe)
> +{
> +	int global_job_id =
> +		atomic_inc_return(&dip_pipe->pipe_job_sequence);
> +
> +	global_job_id =
> +		(global_job_id & 0x0000FFFF) |
> +		(dip_pipe->desc->id << 16);
> +
> +	return global_job_id;
> +}
> +
> +int mtk_dip_pipe_init_job_infos(struct mtk_dip_pipe *dip_pipe)
> +{
> +	int i;
> +
> +	spin_lock(&dip_pipe->job_lock);
> +
> +	dip_pipe->num_pipe_job_infos = ARRAY_SIZE(dip_pipe->pipe_job_infos);
> +	INIT_LIST_HEAD(&dip_pipe->pipe_job_running_list);
> +	INIT_LIST_HEAD(&dip_pipe->pipe_job_free_list);
> +
> +	for (i = 0; i < dip_pipe->num_pipe_job_infos; i++) {
> +		struct mtk_dip_pipe_job_info *pipe_job_info =
> +			&dip_pipe->pipe_job_infos[i];
> +		list_add_tail(&pipe_job_info->list,
> +			      &dip_pipe->pipe_job_free_list);
> +	}
> +
> +	spin_unlock(&dip_pipe->job_lock);
> +
> +	return 0;
> +}
> +
> +static int mtk_dip_pipe_process_pipe_job_info(struct mtk_dip_pipe *dip_pipe,
> +					      struct mtk_dip_pipe_job_info
> +					      *pipe_job_info)
> +{
> +	spin_lock(&dip_pipe->job_lock);
> +
> +	list_del(&pipe_job_info->list);
> +	list_add_tail(&pipe_job_info->list, &dip_pipe->pipe_job_running_list);
> +
> +	spin_unlock(&dip_pipe->job_lock);
> +	return 0;
> +}
> +
> +struct mtk_dip_pipe_job_info *
> +mtk_dip_pipe_get_running_job_info(struct mtk_dip_pipe *dip_pipe,
> +				  int pipe_job_id)
> +{
> +	struct mtk_dip_pipe_job_info *pipe_job_info = NULL;
> +
> +	spin_lock(&dip_pipe->job_lock);
> +
> +	list_for_each_entry(pipe_job_info,
> +			    &dip_pipe->pipe_job_running_list, list) {
> +		if (pipe_job_info->id == pipe_job_id) {
> +			spin_unlock(&dip_pipe->job_lock);
> +			return pipe_job_info;
> +		}
> +	}
> +
> +	spin_unlock(&dip_pipe->job_lock);
> +
> +	return NULL;
> +}
> +
> +static int
> +mtk_dip_pipe_free_job_info(struct mtk_dip_pipe *dip_pipe,
> +			   struct mtk_dip_pipe_job_info *pipe_job_info)
> +{
> +	spin_lock(&dip_pipe->job_lock);
> +
> +	list_del(&pipe_job_info->list);
> +	list_add_tail(&pipe_job_info->list, &dip_pipe->pipe_job_free_list);
> +
> +	spin_unlock(&dip_pipe->job_lock);
> +
> +	return 0;
> +}
> +
> +static struct mtk_dip_pipe_job_info *
> +mtk_dip_pipe_get_free_job_info(struct mtk_dip_pipe *dip_pipe)
> +{
> +	struct mtk_dip_pipe_job_info *pipe_job_info = NULL;
> +
> +	spin_lock(&dip_pipe->job_lock);
> +	list_for_each_entry(pipe_job_info,
> +			    &dip_pipe->pipe_job_free_list, list) {
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev, "Found free pipe job\n");
> +		spin_unlock(&dip_pipe->job_lock);
> +		return pipe_job_info;
> +	}
> +	spin_unlock(&dip_pipe->job_lock);
> +
> +	dev_err(&dip_pipe->dip_dev->pdev->dev,
> +		"%s: can't found free pipe job\n",
> +		dip_pipe->desc->name);
> +
> +	return NULL;
> +}
> +
> +static void
> +mtk_dip_pipe_update_job_info(struct mtk_dip_pipe *dip_pipe,
> +			     struct mtk_dip_pipe_job_info *pipe_job_info,
> +			     struct mtk_dip_video_device *node,
> +			     struct mtk_dip_dev_buffer *dev_buf)
> +{
> +	if (!pipe_job_info || !dev_buf || !node) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: update pipe-job(%p) failed, buf(%p),node(%p)\n",
> +			dip_pipe->desc->name,
> +			pipe_job_info, dev_buf, node);
> +		return;
> +	}
> +
> +	if (pipe_job_info->buf_map[node->desc->id])
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +			"%s:%s: buf overwrite\n",
> +			 dip_pipe->desc->name,
> +			 node->desc->name);
> +
> +	if (node->desc->buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
> +		pipe_job_info->num_img_capture_bufs++;
> +
> +	if (node->desc->buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
> +		pipe_job_info->num_img_output_bufs++;
> +
> +	if (node->desc->buf_type == V4L2_BUF_TYPE_META_OUTPUT)
> +		pipe_job_info->num_meta_output_bufs++;
> +
> +	if (node->desc->buf_type == V4L2_BUF_TYPE_META_CAPTURE)
> +		pipe_job_info->num_meta_capture_bufs++;
> +
> +	pipe_job_info->buf_map[node->desc->id] = dev_buf;
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s:%s: added buf(%p) to pipe-job(%p)\n",
> +		dip_pipe->desc->name, node->desc->name, dev_buf,
> +		pipe_job_info);
> +}
> +
> +static void mtk_dip_pipe_debug_job(struct mtk_dip_pipe *dip_pipe,
> +				   struct mtk_dip_pipe_job_info *pipe_job_info)
> +{
> +	int i;
> +
> +	if (!dip_pipe || !pipe_job_info)
> +		return;
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s: pipe-job(%p),id(%d),req(%p)buf nums(%d,%d,%d,%d)\n",
> +		dip_pipe->desc->name,
> +		pipe_job_info,
> +		pipe_job_info->id,
> +		pipe_job_info->req,
> +		pipe_job_info->num_img_capture_bufs,
> +		pipe_job_info->num_img_output_bufs,
> +		pipe_job_info->num_meta_capture_bufs,
> +		pipe_job_info->num_meta_output_bufs);
> +
> +	for (i = 0; i < MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM ; i++) {
> +		if (pipe_job_info->buf_map[i])
> +			dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +				"Node(%s,%d), buf(%p)\n",
> +				dip_pipe->nodes[i].desc->name, i,
> +				pipe_job_info->buf_map[i]);
> +	}
> +}
> +
> +int mtk_dip_pipe_job_finish(struct mtk_dip_pipe *dip_pipe,
> +			    unsigned int pipe_job_info_id,
> +			    enum vb2_buffer_state vbf_state)
> +{
> +	int i;
> +	struct mtk_dip_pipe_job_info *job_info = NULL;
> +	const int pipe_id =
> +		mtk_dip_pipe_get_pipe_from_job_id(pipe_job_info_id);
> +	u64 timestamp = 0;
> +
> +	if (!dip_pipe)
> +		pr_err("%s: pipe-job id(%d) release failed, dip_pipe is null\n",
> +		       __func__, pipe_job_info_id);
> +
> +	job_info = mtk_dip_pipe_get_running_job_info(dip_pipe,
> +						     pipe_job_info_id);
> +
> +	if (!job_info) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s:%s: can't find pipe-job id(%d)\n",
> +			__func__, dip_pipe->desc->name, pipe_id);
> +		return -EINVAL;
> +	}
> +
> +	timestamp = ktime_get_ns();
> +
> +	for (i = 0; i < MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM; i++) {
> +		struct mtk_dip_dev_buffer *dev_buf = job_info->buf_map[i];
> +
> +		if (!dev_buf) {
> +			continue;
> +		} else {
> +			dev_buf->vbb.vb2_buf.timestamp = ktime_get_ns();
> +			mtk_dip_v4l2_buffer_done(&dev_buf->vbb.vb2_buf,
> +						 vbf_state);
> +		}
> +	}
> +
> +	mtk_dip_pipe_free_job_info(dip_pipe, job_info);
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s:%s: finish pipe-job, id(%d), vb state(%d)\n",
> +		__func__, dip_pipe->desc->name, pipe_id,
> +		pipe_job_info_id, vbf_state);

The format string does not match the arguments. There are two ids in the
arguments but only one %d for them.

> +
> +	return 0;
> +}
> +
> +static void mtk_dip_dev_buf_fill_info(struct mtk_dip_pipe *dip_pipe,
> +				      struct mtk_dip_dev_buffer *dev_buf)
> +{
> +	struct vb2_v4l2_buffer *b;
> +	struct mtk_dip_video_device *node;
> +	struct mtk_dip_video_device_desc *desc;
> +
> +	b = &dev_buf->vbb;
> +	node = mtk_dip_vbq_to_node(b->vb2_buf.vb2_queue);
> +	desc = node->desc;
> +	dev_buf->fmt = node->vdev_fmt;
> +	dev_buf->dev_fmt = node->dev_q.dev_fmt;
> +	dev_buf->isp_daddr =
> +		vb2_dma_contig_plane_dma_addr(&b->vb2_buf, 0);
> +	dev_buf->vaddr = vb2_plane_vaddr(&b->vb2_buf, 0);
> +	dev_buf->buffer_usage = node->dev_q.buffer_usage;
> +	dev_buf->rotation = node->dev_q.rotation;
> +
> +	if (desc->smem_alloc) {
> +		dev_buf->scp_daddr =
> +			mtk_dip_smem_iova_to_phys
> +			(dip_pipe->smem_alloc_dev,
> +			 dev_buf->isp_daddr);
> +	} else {
> +		dev_buf->scp_daddr = 0;
> +	}
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s:%s: buf type(%d), idx(%d), mem(%d), isp_daddr(%p), scp_daddr(%p)\n",
> +		dip_pipe->desc->name,
> +		desc->name,
> +		b->vb2_buf.type,
> +		b->vb2_buf.index,
> +		b->vb2_buf.memory,
> +		dev_buf->isp_daddr,
> +		dev_buf->scp_daddr);
> +}
> +
> +int mtk_dip_pipe_queue_buffers(struct media_request *req,
> +			       int initial)
> +{
> +	struct media_request_object *obj;
> +	struct mtk_dip_pipe *dip_pipe;
> +	struct mtk_dip_pipe_job_info *pipe_job_info = NULL;
> +	int ret = 0;
> +
> +	list_for_each_entry(obj, &req->objects, list) {
> +		struct vb2_buffer *vb;
> +
> +		if (vb2_request_object_is_buffer(obj)) {
> +			struct mtk_dip_dev_buffer *buf;
> +			struct mtk_dip_dev_buffer *dev_buf;
> +			struct mtk_dip_video_device *node;
> +
> +			vb = container_of(obj, struct vb2_buffer, req_obj);
> +			node = mtk_dip_vbq_to_node(vb->vb2_queue);
> +			dip_pipe = vb2_get_drv_priv(vb->vb2_queue);
> +			dev_buf = mtk_dip_vb2_buf_to_dev_buf(vb);
> +			buf = dev_buf;
> +
> +			if (!pipe_job_info) {
> +				pipe_job_info = mtk_dip_pipe_get_free_job_info
> +					(dip_pipe);
> +
> +				if (!pipe_job_info)
> +					goto FAILE_JOB_NOT_TRIGGER;
> +
> +				memset(pipe_job_info->buf_map, 0,
> +				       sizeof(pipe_job_info->buf_map));
> +				pipe_job_info->num_img_capture_bufs = 0;
> +				pipe_job_info->num_img_output_bufs = 0;
> +				pipe_job_info->num_meta_capture_bufs = 0;
> +				pipe_job_info->num_meta_output_bufs = 0;
> +			}
> +
> +			mtk_dip_dev_buf_fill_info(dip_pipe,
> +						  buf);
> +
> +			mtk_dip_pipe_update_job_info(dip_pipe,
> +						     pipe_job_info,
> +						     node,
> +						     buf);
> +		}
> +	}
> +
> +	if (!pipe_job_info)
> +		return -EINVAL;
> +
> +	pipe_job_info->id =
> +		mtk_dip_pipe_next_job_id(dip_pipe);
> +
> +	mtk_dip_pipe_debug_job(dip_pipe, pipe_job_info);
> +
> +	mutex_lock(&dip_pipe->lock);
> +
> +	if (!dip_pipe->streaming) {
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +			"%s:%s:  stream is off, no hw enqueue triggered\n",
> +			__func__, dip_pipe->desc->name);
> +		mutex_unlock(&dip_pipe->lock);
> +		return 0;
> +	}
> +
> +	if (mtk_dip_pipe_process_pipe_job_info(dip_pipe, pipe_job_info)) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s:%s: can't start to run pipe job id(%d)\n",
> +			__func__, dip_pipe->desc->name,
> +			pipe_job_info->id);
> +		mutex_unlock(&dip_pipe->lock);
> +		goto FAILE_JOB_NOT_TRIGGER;
> +	}
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s: trigger pipe job, id(%d)\n",
> +		dip_pipe->desc->name,
> +		dip_pipe->desc->id);
> +
> +	if (mtk_dip_pipe_job_start(dip_pipe, pipe_job_info)) {
> +		mutex_unlock(&dip_pipe->lock);
> +		goto FAILE_JOB_NOT_TRIGGER;
> +	}
> +
> +	mutex_unlock(&dip_pipe->lock);
> +
> +	return 0;
> +
> +FAILE_JOB_NOT_TRIGGER:

The label should be snake_case. Is "FAILE" a typo of "FAILED"?

> +	if (initial)
> +		return ret;
> +
> +	mtk_dip_pipe_job_finish(dip_pipe, pipe_job_info->id,
> +				VB2_BUF_STATE_ERROR);
> +
> +	return -EINVAL;
> +}
> +
> +int mtk_dip_pipe_release(struct mtk_dip_pipe *dip_pipe)
> +{
> +	mtk_dip_pipe_v4l2_unregister(dip_pipe);
> +	v4l2_ctrl_handler_free(&dip_pipe->ctrl_handler);
> +	mutex_destroy(&dip_pipe->lock);
> +
> +	return 0;
> +}
> +
> +static void set_img_fmt(struct v4l2_pix_format_mplane *mfmt_to_fill,
> +			struct mtk_dip_dev_format *dev_fmt)
> +{
> +	int i;
> +
> +	mfmt_to_fill->pixelformat = dev_fmt->fmt.img.pixelformat;
> +	mfmt_to_fill->num_planes = dev_fmt->fmt.img.num_planes;
> +	mfmt_to_fill->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
> +	mfmt_to_fill->quantization = V4L2_QUANTIZATION_DEFAULT;
> +	mfmt_to_fill->colorspace = dev_fmt->fmt.img.colorspace;
> +
> +	memset(mfmt_to_fill->reserved, 0, sizeof(mfmt_to_fill->reserved));
> +
> +	pr_debug("%s: Fmt(%d),w(%d),h(%d),f(%d)\n",
> +		 __func__,
> +		 mfmt_to_fill->pixelformat,
> +		 mfmt_to_fill->width,
> +		 mfmt_to_fill->height,
> +		 mfmt_to_fill->field);
> +
> +	for (i = 0 ; i < mfmt_to_fill->num_planes; ++i) {

Please remove the space after "i = 0".

> +		int bpl = (mfmt_to_fill->width *
> +			dev_fmt->fmt.img.row_depth[i]) / 8;
> +		int sizeimage = (mfmt_to_fill->width * mfmt_to_fill->height *
> +			dev_fmt->fmt.img.depth[i]) / 8;
> +
> +		mfmt_to_fill->plane_fmt[i].bytesperline = bpl;
> +		mfmt_to_fill->plane_fmt[i].sizeimage = sizeimage;
> +		memset(mfmt_to_fill->plane_fmt[i].reserved,
> +		       0, sizeof(mfmt_to_fill->plane_fmt[i].reserved));
> +
> +		pr_debug("plane(%d):bpl(%d),sizeimage(%u)\n",
> +			 i, bpl,
> +			 mfmt_to_fill->plane_fmt[i].sizeimage);
> +	}
> +}
> +
> +static void set_meta_fmt(struct v4l2_meta_format *metafmt_to_fill,
> +			 struct mtk_dip_dev_format *dev_fmt)
> +{
> +	metafmt_to_fill->dataformat = dev_fmt->fmt.meta.dataformat;
> +
> +	if (dev_fmt->fmt.meta.max_buffer_size <= 0) {
> +		pr_debug("Invalid meta buf size(%u), use default(%u)\n",
> +			 dev_fmt->fmt.meta.max_buffer_size,
> +			 MTK_DIP_DEV_META_BUF_DEFAULT_SIZE);
> +		metafmt_to_fill->buffersize = MTK_DIP_DEV_META_BUF_DEFAULT_SIZE;
> +	} else {
> +		pr_debug("Use meta size(%u)\n",
> +			 dev_fmt->fmt.meta.max_buffer_size);
> +		metafmt_to_fill->buffersize = dev_fmt->fmt.meta.max_buffer_size;
> +	}
> +}
> +
> +void mtk_dip_pipe_load_default_fmt(struct mtk_dip_pipe *dip_pipe,
> +				   struct mtk_dip_video_device *node,
> +				   struct v4l2_format *fmt_to_fill)
> +{
> +	struct mtk_dip_dev_format *dev_fmt;
> +	struct mtk_dip_video_device_desc *desc = node->desc;
> +
> +	if (desc->num_fmts == 0) {
> +		pr_err("%s:%s: desc->num_fmts is 0, no format support list\n",
> +		       __func__, desc->name);
> +		return;
> +	}
> +
> +	if (desc->default_fmt_idx >= desc->num_fmts) {
> +		pr_debug("%s:%s: invalid idx(%d), must < num_fmts(%d)\n",
> +			 __func__, desc->name, desc->default_fmt_idx,
> +			desc->num_fmts);
> +		desc->default_fmt_idx = 0;
> +	}
> +
> +	dev_fmt	= &desc->fmts[desc->default_fmt_idx];
> +	fmt_to_fill->type = desc->buf_type;
> +	if (mtk_dip_buf_is_meta(desc->buf_type)) {
> +		set_meta_fmt(&fmt_to_fill->fmt.meta, dev_fmt);
> +	} else {
> +		fmt_to_fill->fmt.pix_mp.width = desc->default_width;
> +		fmt_to_fill->fmt.pix_mp.height = desc->default_height;
> +		fmt_to_fill->fmt.pix_mp.field = V4L2_FIELD_NONE;
> +
> +		set_img_fmt(&fmt_to_fill->fmt.pix_mp, dev_fmt);
> +	}
> +}
> +
> +struct mtk_dip_dev_format *
> +mtk_dip_pipe_find_fmt(struct mtk_dip_pipe *dip_pipe,
> +		      struct mtk_dip_video_device *node,
> +		      u32 format)
> +{
> +	int i;
> +	struct mtk_dip_dev_format *dev_fmt;
> +
> +	struct mtk_dip_video_device_desc *desc = node->desc;
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev, "fmt to find(%x)\n", format);
> +
> +	for (i = 0; i < desc->num_fmts; i++) {
> +		dev_fmt = &desc->fmts[i];
> +		if (!mtk_dip_buf_is_meta(desc->buf_type)) {
> +			if (dev_fmt->fmt.img.pixelformat == format)
> +				return dev_fmt;
> +		} else {
> +			if (dev_fmt->fmt.meta.dataformat == format)
> +				return dev_fmt;
> +		}
> +	}
> +
> +	return NULL;
> +}
> +
> +int mtk_dip_pipe_set_meta_fmt(struct mtk_dip_pipe *dip_pipe,
> +			      struct mtk_dip_video_device *node,
> +			      struct v4l2_meta_format *user_fmt,
> +			      struct v4l2_meta_format *node_fmt)
> +{
> +	struct mtk_dip_dev_format *dev_fmt;
> +
> +	if (!user_fmt || !node_fmt)
> +		return -EINVAL;
> +
> +	dev_fmt = mtk_dip_pipe_find_fmt(dip_pipe, node,
> +					user_fmt->dataformat);
> +
> +	if (!dev_fmt)
> +		return -EINVAL;
> +
> +	node->dev_q.dev_fmt = dev_fmt;
> +	set_meta_fmt(node_fmt, dev_fmt);
> +	*user_fmt = *node_fmt;
> +
> +	return 0;
> +}
> +
> +int mtk_dip_pipe_set_img_fmt(struct mtk_dip_pipe *dip_pipe,
> +			     struct mtk_dip_video_device *node,
> +			     struct v4l2_pix_format_mplane *user_fmt,
> +			     struct v4l2_pix_format_mplane *dest_fmt)
> +{
> +	struct mtk_dip_dev_format *dev_fmt;
> +
> +	if (!user_fmt || !dest_fmt)
> +		return -EINVAL;
> +
> +	dev_fmt = mtk_dip_pipe_find_fmt(dip_pipe, node,
> +					user_fmt->pixelformat);
> +
> +	if (!dev_fmt) {
> +		pr_debug("%s:%s:%s: dev_fmt(%d) not found\n",
> +			 __func__, dip_pipe->desc->name,
> +			 node->desc->name, user_fmt->pixelformat);
> +		return -EINVAL;
> +	}
> +
> +	node->dev_q.dev_fmt = dev_fmt;
> +	dest_fmt->width = user_fmt->width;
> +	dest_fmt->height = user_fmt->height;
> +	dest_fmt->field = V4L2_FIELD_NONE;
> +
> +	set_img_fmt(dest_fmt, dev_fmt);
> +
> +	return 0;
> +}
> +
> +int mtk_dip_pipe_streamon(struct mtk_dip_pipe *dip_pipe)
> +{
> +	int ret;
> +	struct mtk_dip_dev *dip_dev;
> +
> +	if (!dip_pipe)
> +		return -EINVAL;
> +
> +	dip_dev = dev_get_drvdata(&dip_pipe->dip_dev->pdev->dev);
> +
> +	mutex_lock(&dip_pipe->lock);
> +
> +	ret = mtk_dip_hw_streamon(&dip_dev->dip_hw,
> +				  dip_pipe->desc->id);
> +
> +	if (ret) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s:%s:%d: failed to start hw\n",
> +			__func__, dip_pipe->desc->name,
> +			dip_pipe->desc->id);
> +		mutex_unlock(&dip_pipe->lock);
> +		return -EBUSY;
> +	}
> +
> +	dip_pipe->streaming = 1;
> +	mutex_unlock(&dip_pipe->lock);
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s:%s:%d: start hw\n",
> +		__func__, dip_pipe->desc->name,
> +		dip_pipe->desc->id);
> +
> +	return ret;
> +}
> +
> +int mtk_dip_pipe_streamoff(struct mtk_dip_pipe *dip_pipe)
> +{
> +	int ret;
> +	struct mtk_dip_dev *dip_dev;
> +
> +	if (!dip_pipe)
> +		return -EINVAL;
> +
> +	dip_dev = dev_get_drvdata(&dip_pipe->dip_dev->pdev->dev);
> +
> +	mutex_lock(&dip_pipe->lock);
> +
> +	ret = mtk_dip_hw_streamoff(&dip_dev->dip_hw,
> +				   dip_pipe->desc->id);
> +
> +	if (ret) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s:%s:%d: failed to stop hw\n",
> +			__func__, dip_pipe->desc->name,
> +			dip_pipe->desc->id);
> +		mutex_unlock(&dip_pipe->lock);
> +		return -EBUSY;
> +	}
> +
> +	dip_pipe->streaming = 0;
> +	mutex_unlock(&dip_pipe->lock);
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s:%s:%d: stop hw\n",
> +		__func__, dip_pipe->desc->name,
> +		dip_pipe->desc->id);
> +
> +	return 0;
> +}
> +
> +static enum mdp_ycbcr_profile
> +map_ycbcr_prof_mplane(struct v4l2_pix_format_mplane *pix_mp,
> +		      u32 mdp_color)
> +{
> +	if (MDP_COLOR_IS_RGB(mdp_color))
> +		return MDP_YCBCR_PROFILE_FULL_BT601;
> +
> +	switch (pix_mp->colorspace) {
> +	case V4L2_COLORSPACE_JPEG:
> +		return MDP_YCBCR_PROFILE_JPEG;
> +	case V4L2_COLORSPACE_REC709:
> +	case V4L2_COLORSPACE_DCI_P3:
> +		if (pix_mp->quantization == V4L2_QUANTIZATION_FULL_RANGE)
> +			return MDP_YCBCR_PROFILE_FULL_BT709;
> +		return MDP_YCBCR_PROFILE_BT709;
> +	case V4L2_COLORSPACE_BT2020:
> +		if (pix_mp->quantization == V4L2_QUANTIZATION_FULL_RANGE)
> +			return MDP_YCBCR_PROFILE_FULL_BT2020;
> +		return MDP_YCBCR_PROFILE_BT2020;
> +	}
> +	/* V4L2_COLORSPACE_SRGB or else */
> +	if (pix_mp->quantization == V4L2_QUANTIZATION_FULL_RANGE)
> +		return MDP_YCBCR_PROFILE_FULL_BT601;
> +	return MDP_YCBCR_PROFILE_BT601;
> +}
> +
> +/* Stride that is accepted by MDP HW */
> +static u32 dip_mdp_fmt_get_stride(const struct mtk_dip_dev_mdp_format *fmt,
> +				  u32 bytesperline,
> +				  unsigned int plane)
> +{
> +	enum mdp_color c = fmt->mdp_color;
> +	u32 stride;
> +
> +	stride = (bytesperline * MDP_COLOR_BITS_PER_PIXEL(c))
> +		/ fmt->row_depth[0];
> +	if (plane == 0)
> +		return stride;
> +	if (plane < MDP_COLOR_GET_PLANE_COUNT(c)) {
> +		if (MDP_COLOR_IS_BLOCK_MODE(c))
> +			stride = stride / 2;
> +		return stride;
> +	}
> +	return 0;
> +}
> +
> +/* Stride that is accepted by MDP HW of format with contiguous planes */
> +static u32
> +dip_mdp_fmt_get_stride_contig(const struct mtk_dip_dev_mdp_format *fmt,
> +			      u32 pix_stride,
> +			      unsigned int plane)
> +{
> +	enum mdp_color c = fmt->mdp_color;
> +	u32 stride = pix_stride;
> +
> +	if (plane == 0)
> +		return stride;
> +	if (plane < MDP_COLOR_GET_PLANE_COUNT(c)) {
> +		stride = stride >> MDP_COLOR_GET_H_SUBSAMPLE(c);
> +		if (MDP_COLOR_IS_UV_COPLANE(c) && !MDP_COLOR_IS_BLOCK_MODE(c))
> +			stride = stride * 2;
> +		return stride;
> +	}
> +	return 0;
> +}
> +
> +/* Plane size that is accepted by MDP HW */
> +static u32
> +dip_mdp_fmt_get_plane_size(const struct mtk_dip_dev_mdp_format *fmt,
> +			   u32 stride, u32 height,
> +			   unsigned int plane)
> +{
> +	enum mdp_color c = fmt->mdp_color;
> +	u32 bytesperline;
> +
> +	bytesperline = (stride * fmt->row_depth[0])
> +		/ MDP_COLOR_BITS_PER_PIXEL(c);
> +	if (plane == 0)
> +		return bytesperline * height;
> +	if (plane < MDP_COLOR_GET_PLANE_COUNT(c)) {
> +		height = height >> MDP_COLOR_GET_V_SUBSAMPLE(c);
> +		if (MDP_COLOR_IS_BLOCK_MODE(c))
> +			bytesperline = bytesperline * 2;
> +		return bytesperline * height;
> +	}
> +	return 0;
> +}
> +
> +static int is_contig_mp_buffer(struct mtk_dip_dev_buffer *dev_buf)
> +{
> +	if (MDP_COLOR_GET_PLANE_COUNT(dev_buf->dev_fmt->fmt.img.mdp_color)
> +	    == 1)
> +		return 0;
> +	else
> +		return 1;
> +}
> +
> +static int fill_ipi_img_param_mp(struct mtk_dip_pipe *dip_pipe,
> +				 struct img_image_buffer *b,
> +				 struct mtk_dip_dev_buffer *dev_buf,
> +				 char *buf_name)
> +{
> +	struct v4l2_pix_format_mplane *pix_mp;
> +	struct mtk_dip_dev_mdp_format *mdp_fmt;
> +	unsigned int i;
> +	unsigned int total_plane_size = 0;
> +
> +	if (!dev_buf || !dev_buf->dev_fmt) {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: %s's dev format not set\n",
> +			__func__, buf_name);
> +		return -EINVAL;
> +	}
> +
> +	pix_mp = &dev_buf->fmt.fmt.pix_mp;
> +	mdp_fmt = &dev_buf->dev_fmt->fmt.img;
> +
> +	b->format.colorformat = dev_buf->dev_fmt->fmt.img.mdp_color;
> +	b->format.width = dev_buf->fmt.fmt.pix_mp.width;
> +	b->format.height = dev_buf->fmt.fmt.pix_mp.height;
> +	b->format.ycbcr_prof =
> +		map_ycbcr_prof_mplane(pix_mp,
> +				      dev_buf->dev_fmt->fmt.img.mdp_color);
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s: buf(%s), IPI: w(%d),h(%d),c(0x%x)\n",
> +		dip_pipe->desc->name,
> +		buf_name,
> +		b->format.width,
> +		b->format.height,
> +		b->format.colorformat);
> +
> +	for (i = 0; i < pix_mp->num_planes; ++i) {
> +		u32 stride =
> +			dip_mdp_fmt_get_stride
> +			(mdp_fmt, pix_mp->plane_fmt[i].bytesperline, i);
> +
> +		b->format.plane_fmt[i].stride = stride;
> +		b->format.plane_fmt[i].size =
> +			dip_mdp_fmt_get_plane_size(mdp_fmt,
> +						   stride,
> +						   pix_mp->height, i);
> +		b->iova[i] = dev_buf->isp_daddr;
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +			"Contiguous-mp-buf:plane(%i),stride(%d),size(%d),iova(%p)",
> +			i,
> +			b->format.plane_fmt[i].stride,
> +			b->format.plane_fmt[i].size,
> +			b->iova[i]);

iova is an u32, so should we use %x instead of %llx here?

> +		total_plane_size = b->format.plane_fmt[i].size;
> +	}
> +
> +	for (; i < MDP_COLOR_GET_PLANE_COUNT(b->format.colorformat); ++i) {
> +		u32 stride =
> +			dip_mdp_fmt_get_stride_contig
> +			(mdp_fmt, b->format.plane_fmt[0].stride, i);
> +
> +		b->format.plane_fmt[i].stride = stride;
> +		b->format.plane_fmt[i].size =
> +			dip_mdp_fmt_get_plane_size(mdp_fmt, stride,
> +						   pix_mp->height, i);
> +		b->iova[i] = b->iova[i - 1] + b->format.plane_fmt[i - 1].size;
> +		dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +			"Contiguous-mp-buf:plane(%i),stride(%d),size(%d),iova(%p)",
> +			i,
> +			b->format.plane_fmt[i].stride,
> +			b->format.plane_fmt[i].size,
> +			b->iova[i]);

iova is an u32, so should we use %x instead of %llx here?

> +		total_plane_size += b->format.plane_fmt[i].size;
> +	}
> +
> +	b->usage = dev_buf->buffer_usage;
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"Contiguous-mp-buf(%s),v4l2-sizeimage(%d),total-plane-size(%d)\n",
> +		buf_name,
> +		pix_mp->plane_fmt[0].sizeimage,
> +		total_plane_size);
> +
> +	return 0;
> +}
> +
> +static int fill_ipi_img_param(struct mtk_dip_pipe *dip_pipe,
> +			      struct img_image_buffer *img,
> +			      struct mtk_dip_dev_buffer *dev_buf,
> +			      char *buf_name)
> +{
> +	img->format.width = dev_buf->fmt.fmt.pix_mp.width;
> +	img->format.height = dev_buf->fmt.fmt.pix_mp.height;
> +
> +	if (dev_buf && dev_buf->dev_fmt) {
> +		img->format.colorformat =
> +			dev_buf->dev_fmt->fmt.img.mdp_color;
> +	} else {
> +		dev_err(&dip_pipe->dip_dev->pdev->dev,
> +			"%s: %s's dev format not set\n",
> +			__func__, buf_name);
> +		return -EINVAL;
> +	}
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s: buf(%s) IPI: w(%d),h(%d),c(0x%x)\n",
> +		dip_pipe->desc->name,
> +		buf_name,
> +		img->format.width,
> +		img->format.height,
> +		img->format.colorformat);
> +
> +	img->format.plane_fmt[0].size =
> +		dev_buf->fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
> +	img->format.plane_fmt[0].stride =
> +		dev_buf->fmt.fmt.pix_mp.plane_fmt[0].bytesperline;
> +	img->iova[0] = dev_buf->isp_daddr;
> +	img->usage = dev_buf->buffer_usage;
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"size(%d), stride(%d),ycbcr(%d),iova(%p),u(%d)\n",
> +		img->format.plane_fmt[0].size,
> +		img->format.plane_fmt[0].stride,
> +		img->format.ycbcr_prof,
> +		img->iova[0],
> +		img->usage);
> +
> +	return 0;
> +}
> +
> +static int fill_input_ipi_param(struct mtk_dip_pipe *dip_pipe,
> +				struct img_input *iin,
> +				struct mtk_dip_dev_buffer *dev_buf,
> +				char *buf_name)
> +{
> +	struct img_image_buffer *img = &iin->buffer;
> +
> +	/* Will map the vale with V4L2 color space in the future */

typo? vale => value

> +	img->format.ycbcr_prof = 1;
> +	if (is_contig_mp_buffer(dev_buf))
> +		return fill_ipi_img_param_mp(dip_pipe, img, dev_buf,
> +					     buf_name);
> +	else
> +		return fill_ipi_img_param(dip_pipe, img, dev_buf,
> +					  buf_name);
> +}
> +
> +static int fill_output_ipi_param(struct mtk_dip_pipe *dip_pipe,
> +				 struct img_output *iout,
> +				 struct mtk_dip_dev_buffer *dev_buf_out,
> +				 struct mtk_dip_dev_buffer *dev_buf_in,
> +				 char *buf_name)
> +{
> +	int ret;
> +	struct img_image_buffer *img = &iout->buffer;
> +
> +	img->format.ycbcr_prof = 0;
> +
> +	if (is_contig_mp_buffer(dev_buf_out))
> +		ret = fill_ipi_img_param_mp(dip_pipe, img, dev_buf_out,
> +					    buf_name);
> +	else
> +		ret = fill_ipi_img_param(dip_pipe, img, dev_buf_out,
> +					 buf_name);
> +
> +	iout->crop.left = 0;
> +	iout->crop.top = 0;
> +	iout->crop.width = dev_buf_in->fmt.fmt.pix_mp.width;
> +	iout->crop.height = dev_buf_in->fmt.fmt.pix_mp.height;
> +	iout->crop.left_subpix = 0;
> +	iout->crop.top_subpix = 0;
> +	iout->crop.width_subpix = 0;
> +	iout->crop.height_subpix = 0;
> +	iout->rotation = dev_buf_out->rotation;
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"%s: buf(%s) IPI-ext:c_l(%d),c_t(%d),c_w(%d),c_h(%d)\n",
> +		dip_pipe->desc->name,
> +		buf_name,
> +		iout->crop.left,
> +		iout->crop.top,
> +		iout->crop.width,
> +		iout->crop.height);
> +
> +	dev_dbg(&dip_pipe->dip_dev->pdev->dev,
> +		"c_ls(%d),c_ts(%d),c_ws(%d),c_hs(%d),rot(%d)\n",
> +		iout->crop.left_subpix,
> +		iout->crop.top_subpix,
> +		iout->crop.width_subpix,
> +		iout->crop.height_subpix,
> +		iout->rotation);
> +
> +	return ret;
> +}
> +
> +int mtk_dip_pipe_job_start(struct mtk_dip_pipe *dip_pipe,
> +			   struct mtk_dip_pipe_job_info *pipe_job_info)
> +{
> +	struct platform_device *pdev = dip_pipe->dip_dev->pdev;
> +	int ret;
> +	int out_img_buf_idx;
> +	struct img_ipi_frameparam dip_param;
> +	struct mtk_dip_dev_buffer *dev_buf_in;
> +	struct mtk_dip_dev_buffer *dev_buf_out;
> +	struct mtk_dip_dev_buffer *dev_buf_tuning;
> +
> +	if (!pipe_job_info) {
> +		dev_err(&pdev->dev,
> +			"pipe_job_info(%p) in start can't be NULL\n",
> +			pipe_job_info);
> +		return -EINVAL;
> +	}
> +
> +	/* We need RAW and at least MDP0 or MDP 1 buffer */
> +	if (!pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_RAW_OUT] ||
> +	    (!pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_MDP0_CAPTURE] &&
> +		 !pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_MDP1_CAPTURE])){
> +		struct mtk_dip_dev_buffer **map = pipe_job_info->buf_map;
> +
> +		dev_dbg(&pdev->dev,
> +			"can't trigger job: raw(%p), mdp0(%p), mdp1(%p)\n",
> +			map[MTK_DIP_VIDEO_NODE_ID_RAW_OUT],
> +			map[MTK_DIP_VIDEO_NODE_ID_MDP0_CAPTURE],
> +			map[MTK_DIP_VIDEO_NODE_ID_MDP1_CAPTURE]);
> +		return -EINVAL;
> +	}
> +
> +	dev_dbg(&pdev->dev,
> +		"%s:%s: pipe-job id(%d)\n",
> +		__func__, dip_pipe->desc->name,
> +		pipe_job_info->id);
> +
> +	/* Fill ipi params for DIP driver */
> +	memset(&dip_param, 0, sizeof(struct img_ipi_frameparam));
> +
> +	dip_param.index = pipe_job_info->id;
> +	dip_param.num_outputs = pipe_job_info->num_img_capture_bufs;
> +	dip_param.num_inputs = pipe_job_info->num_img_output_bufs;
> +	dip_param.type = STREAM_ISP_IC;
> +
> +	/* Tuning buffer */
> +	dev_buf_tuning =
> +		pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_TUNING_OUT];
> +	if (dev_buf_tuning) {
> +		dev_dbg(&pdev->dev,
> +			"Tuning buf queued: pa(%p),va(%p),iova(%p)\n",
> +			dev_buf_tuning->scp_daddr,
> +			dev_buf_tuning->vaddr,
> +			dev_buf_tuning->isp_daddr);
> +		dip_param.tuning_data.pa = (uint32_t)dev_buf_tuning->scp_daddr;
> +		dip_param.tuning_data.va = (uint64_t)dev_buf_tuning->vaddr;
> +		dip_param.tuning_data.iova =
> +			(uint32_t)dev_buf_tuning->isp_daddr;
> +	} else {
> +		dev_dbg(&pdev->dev,
> +			"Doesn't enqueued tuning buffer, by-pass\n");
> +	dip_param.tuning_data.pa = 0;
> +	dip_param.tuning_data.va = 0;
> +	dip_param.tuning_data.iova = 0;
> +	}
> +
> +	/* Raw-in buffer */
> +	dev_buf_in =
> +		pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_RAW_OUT];
> +	if (dev_buf_in) {
> +		struct img_input *iin = &dip_param.inputs[0];
> +
> +		fill_input_ipi_param(dip_pipe, iin, dev_buf_in, "RAW");
> +	}
> +
> +	out_img_buf_idx = 0;
> +
> +	/* MDP 0 buffer */
> +	dev_buf_out =
> +		pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_MDP0_CAPTURE];
> +	if (dev_buf_out) {
> +		struct img_output *iout = &dip_param.outputs[out_img_buf_idx];
> +
> +		fill_output_ipi_param(dip_pipe, iout, dev_buf_out,
> +				      dev_buf_in, "MDP0");
> +		out_img_buf_idx++;
> +	}
> +
> +	/* MDP 1 buffer */
> +	dev_buf_out =
> +		pipe_job_info->buf_map[MTK_DIP_VIDEO_NODE_ID_MDP1_CAPTURE];
> +	if (dev_buf_out) {
> +		struct img_output *iout = &dip_param.outputs[out_img_buf_idx];
> +
> +		fill_output_ipi_param(dip_pipe, iout, dev_buf_out,
> +				      dev_buf_in, "MDP1");
> +		out_img_buf_idx++;
> +	}
> +
> +	ret = mtk_dip_hw_enqueue(&dip_pipe->dip_dev->dip_hw, &dip_param);
> +
> +	if (ret) {
> +		dev_dbg(&pdev->dev,
> +			"%s:%s: enqueue to HW failed(%d)\n",
> +			 __func__, dip_pipe->desc->name, ret);
> +		return -EBUSY;
> +	}
> +
> +	return ret;
> +}
> diff --git a/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.h b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.h
> new file mode 100644
> index 000000000000..f51f7a44379a
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-dev.h
> @@ -0,0 +1,321 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Copyright (c) 2018 MediaTek Inc.
> + * Author: Frederic Chen <frederic.chen@mediatek.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#ifndef _MTK_DIP_DEV_H_
> +#define _MTK_DIP_DEV_H_
> +
> +#include <linux/types.h>
> +#include <linux/device.h>
> +#include <linux/platform_device.h>
> +#include <media/v4l2-ctrls.h>
> +#include <media/v4l2-subdev.h>
> +#include <media/v4l2-device.h>
> +#include <linux/videodev2.h>
> +#include <media/videobuf2-core.h>
> +#include <media/videobuf2-v4l2.h>
> +
> +#include "mtk_dip-hw.h"
> +#include "mtk_dip-smem.h"
> +
> +#define MTK_DIP_PIPE_ID_PREVIEW				0
> +#define MTK_DIP_PIPE_ID_CAPTURE				1
> +#define MTK_DIP_PIPE_ID_REPROCESS			2
> +#define MTK_DIP_PIPE_ID_TOTAL_NUM			3
> +
> +#define MTK_DIP_VIDEO_NODE_ID_RAW_OUT			0
> +#define MTK_DIP_VIDEO_NODE_ID_TUNING_OUT		1
> +#define MTK_DIP_VIDEO_NODE_ID_OUT_TOTAL_NUM		2
> +#define MTK_DIP_VIDEO_NODE_ID_MDP0_CAPTURE		2
> +#define MTK_DIP_VIDEO_NODE_ID_MDP1_CAPTURE		3
> +#define MTK_DIP_VIDEO_NODE_ID_CAPTURE_TOTAL_NUM		2
> +#define MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM \
> +	(MTK_DIP_VIDEO_NODE_ID_OUT_TOTAL_NUM + \
> +	MTK_DIP_VIDEO_NODE_ID_CAPTURE_TOTAL_NUM)
> +
> +#define MTK_DIP_VIDEO_NODE_ID_NO_MASTER			-1
> +
> +#define MTK_DIP_OUTPUT_MIN_WIDTH		2U
> +#define MTK_DIP_OUTPUT_MIN_HEIGHT		2U
> +#define MTK_DIP_OUTPUT_MAX_WIDTH		5376U
> +#define MTK_DIP_OUTPUT_MAX_HEIGHT		4032U
> +#define MTK_DIP_CAPTURE_MIN_WIDTH		2U
> +#define MTK_DIP_CAPTURE_MIN_HEIGHT		2U
> +#define MTK_DIP_CAPTURE_MAX_WIDTH		5376U
> +#define MTK_DIP_CAPTURE_MAX_HEIGHT		4032U
> +
> +#define MTK_DIP_DEV_DIP_MEDIA_MODEL_NAME	"MTK-ISP-DIP-V4L2"
> +#define MTK_DIP_DEV_DIP_PREVIEW_NAME \
> +	MTK_DIP_DEV_DIP_MEDIA_MODEL_NAME
> +#define MTK_DIP_DEV_DIP_CAPTURE_NAME		"MTK-ISP-DIP-CAP-V4L2"
> +#define MTK_DIP_DEV_DIP_REPROCESS_NAME		"MTK-ISP-DIP-REP-V4L2"
> +
> +#define MTK_DIP_DEV_META_BUF_DEFAULT_SIZE (1110 * 1024)
> +
> +#define V4L2_CID_PRIVATE_UT_NUM			(V4L2_CID_USER_BASE | 0x1001)
> +#define V4L2_CID_PRIVATE_SET_BUFFER_USAGE	(V4L2_CID_PRIVATE_UT_NUM + 2)
> +#define V4L2_CID_MTK_DIP_MAX			100
> +
> +enum mtk_dip_v4l2_buffer_usage {
> +	MTK_DIP_V4l2_BUF_USAGE_DEFAULT = 0,
> +	MTK_DIP_V4l2_BUF_USAGE_FD,
> +	MTK_DIP_V4l2_BUF_USAGE_POSTPROC,
> +	MTK_DIP_V4l2_BUF_USAGE_NONE,
> +};

The constants in enums should be capitalized. Could we use V4L2 instead of V4l2
here?

> +
> +/*
> + * Supported format and the information used for
> + * size calculation
> + */
> +struct mtk_dip_dev_meta_format {
> +	u32 dataformat;
> +	u32 max_buffer_size;
> +	u8 flags;
> +};
> +
> +/* MDP part private format definitation */
> +struct mtk_dip_dev_mdp_format {
> +	u32 pixelformat;
> +	u32 mdp_color;
> +	u32 colorspace;
> +	u8 depth[VIDEO_MAX_PLANES];
> +	u8 row_depth[VIDEO_MAX_PLANES];
> +	u8 num_planes;
> +	u8 walign;
> +	u8 halign;
> +	u8 salign;
> +	u32 flags;
> +};
> +
> +struct mtk_dip_dev_format {
> +	union {
> +		struct mtk_dip_dev_meta_format meta;
> +		struct mtk_dip_dev_mdp_format img;
> +	} fmt;
> +};
> +
> +struct mtk_dip_pipe_job_info {
> +	struct media_request *req;
> +	int id;
> +	struct mtk_dip_dev_buffer*
> +		buf_map[MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM];
> +	int num_img_capture_bufs;
> +	int num_img_output_bufs;
> +	int num_meta_capture_bufs;
> +	int num_meta_output_bufs;
> +	struct list_head list;
> +};
> +
> +struct mtk_dip_dev_buffer {
> +	struct vb2_v4l2_buffer vbb;
> +	struct v4l2_format fmt;
> +	struct mtk_dip_dev_format *dev_fmt;
> +	int pipe_job_id;
> +	void *vaddr;
> +	dma_addr_t isp_daddr;
> +	dma_addr_t scp_daddr;
> +	unsigned int buffer_usage;
> +	int rotation;
> +	struct list_head list;
> +};
> +
> +struct mtk_dip_pipe_desc {
> +	char *name;
> +	int master;
> +	int id;
> +	struct mtk_dip_video_device_desc *output_queue_descs;
> +	int total_output_queues;
> +	struct mtk_dip_video_device_desc *capture_queue_descs;
> +	int total_capture_queues;
> +};
> +
> +struct mtk_dip_video_device_desc {
> +	int id;
> +	char *name;
> +	u32 buf_type;
> +	u32 cap;
> +	int smem_alloc;
> +	int dynamic;
> +	int default_enable;
> +	struct mtk_dip_dev_format *fmts;
> +	int num_fmts;
> +	char *description;
> +	int default_width;
> +	int default_height;
> +	const struct v4l2_ioctl_ops *ops;
> +	int default_fmt_idx;
> +};
> +
> +struct mtk_dip_dev_queue {
> +	struct vb2_queue vbq;
> +	/* Serializes vb2 queue and video device operations */
> +	struct mutex lock;
> +	struct mtk_dip_dev_format *dev_fmt;
> +	/* Firmware uses buffer_usage to select suitable DMA ports */
> +	unsigned int buffer_usage;
> +	int rotation;
> +};
> +
> +struct mtk_dip_video_device {
> +	struct video_device vdev;
> +	struct mtk_dip_dev_queue dev_q;
> +	struct v4l2_format vdev_fmt;
> +	struct media_pad vdev_pad;
> +	struct v4l2_mbus_framefmt pad_fmt;
> +	struct v4l2_ctrl_handler ctrl_handler;
> +	int immutable;
> +	int enabled;
> +	struct mtk_dip_video_device_desc *desc;
> +	atomic_t sequence;
> +};
> +
> +struct mtk_dip_pipe {
> +	struct mtk_dip_dev *dip_dev;
> +	struct mtk_dip_video_device nodes[MTK_DIP_VIDEO_NODE_ID_TOTAL_NUM];
> +	int num_nodes;
> +	int streaming;
> +	struct media_pad *subdev_pads;
> +	struct media_pipeline pipeline;
> +	struct v4l2_subdev subdev;
> +	struct v4l2_subdev_fh *fh;
> +	struct v4l2_ctrl_handler ctrl_handler;
> +	struct mtk_dip_smem_dev *smem_alloc_dev;
> +	atomic_t pipe_job_sequence;
> +	struct mtk_dip_pipe_job_info pipe_job_infos[VB2_MAX_FRAME];
> +	int num_pipe_job_infos;
> +	struct list_head pipe_job_running_list;
> +	struct list_head pipe_job_free_list;
> +	/* Serializes pipe's stream on/off and buffers enqueue operations */
> +	struct mutex lock;
> +	spinlock_t job_lock; /* protect the pipe job list */
> +	struct mtk_dip_pipe_desc *desc;
> +};
> +
> +struct mtk_dip_dev {
> +	struct platform_device *pdev;
> +	struct media_device mdev;
> +	struct v4l2_device v4l2_dev;
> +	struct mtk_dip_pipe dip_pipe[MTK_DIP_PIPE_ID_TOTAL_NUM];
> +	struct mtk_dip_smem_dev smem_alloc_dev;
> +	struct mtk_dip_hw dip_hw;
> +};
> +
> +int mtk_dip_dev_media_register(struct device *dev,
> +			       struct media_device *media_dev,
> +			       const char *model);
> +
> +int mtk_dip_dev_v4l2_init(struct mtk_dip_dev *dip_dev);
> +
> +void mtk_dip_dev_v4l2_release(struct mtk_dip_dev *dip_dev);
> +
> +int mtk_dip_dev_v4l2_register(struct device *dev,
> +			      struct media_device *media_dev,
> +			      struct v4l2_device *v4l2_dev);
> +
> +int mtk_dip_pipe_v4l2_register(struct mtk_dip_pipe *dip_pipe,
> +			       struct media_device *media_dev,
> +			       struct v4l2_device *v4l2_dev);
> +
> +int mtk_dip_pipe_v4l2_unregister(struct mtk_dip_pipe *dip_pipe);
> +
> +void mtk_dip_v4l2_buffer_done(struct vb2_buffer *vb,
> +			      enum vb2_buffer_state state);
> +
> +int mtk_dip_pipe_queue_buffers(struct media_request *req, int initial);
> +
> +int mtk_dip_pipe_init(struct mtk_dip_pipe *dip_pipe,
> +		      struct mtk_dip_dev *dip_dev,
> +		      struct mtk_dip_pipe_desc *setting,
> +		      struct media_device *media_dev,
> +		      struct v4l2_device *v4l2_dev,
> +		      struct mtk_dip_smem_dev *smem_alloc_dev);
> +
> +int mtk_dip_pipe_release(struct mtk_dip_pipe *dip_pipe);
> +
> +int mtk_dip_pipe_job_finish(struct mtk_dip_pipe *dip_pipe,
> +			    unsigned int pipe_job_info_id,
> +			    enum vb2_buffer_state state);
> +
> +int mtk_dip_pipe_job_start(struct mtk_dip_pipe *dip_pipe,
> +			   struct mtk_dip_pipe_job_info *pipe_job_info);
> +
> +int mtk_dip_pipe_init_job_infos(struct mtk_dip_pipe *dip_pipe);
> +
> +struct mtk_dip_dev_format *
> +mtk_dip_pipe_find_fmt(struct mtk_dip_pipe *dip_pipe,
> +		      struct mtk_dip_video_device *node,
> +		      u32 format);
> +
> +int mtk_dip_pipe_set_img_fmt(struct mtk_dip_pipe *dip_pipe,
> +			     struct mtk_dip_video_device *node,
> +			     struct v4l2_pix_format_mplane *user_fmt,
> +			     struct v4l2_pix_format_mplane *node_fmt);
> +
> +int mtk_dip_pipe_set_meta_fmt(struct mtk_dip_pipe *dip_pipe,
> +			      struct mtk_dip_video_device *node,
> +			      struct v4l2_meta_format *user_fmt,
> +			      struct v4l2_meta_format *node_fmt);

Where do we use this function?

> +
> +void mtk_dip_pipe_load_default_fmt(struct mtk_dip_pipe *dip_pipe,
> +				   struct mtk_dip_video_device *node,
> +				   struct v4l2_format *fmt_to_fill);
> +
> +int mtk_dip_pipe_streamon(struct mtk_dip_pipe *dip_pipe);
> +
> +int mtk_dip_pipe_streamoff(struct mtk_dip_pipe *dip_pipe);
> +
> +int mtk_dip_ctrl_init(struct mtk_dip_pipe *dip_pipe);
> +
> +static inline struct mtk_dip_video_device *
> +mtk_dip_file_to_node(struct file *file)
> +{
> +	return container_of(video_devdata(file),
> +			    struct mtk_dip_video_device, vdev);
> +}
> +
> +static inline struct mtk_dip_pipe *
> +mtk_dip_subdev_to_pipe(struct v4l2_subdev *sd)
> +{
> +	return container_of(sd, struct mtk_dip_pipe, subdev);
> +}
> +
> +static inline struct mtk_dip_video_device *
> +mtk_dip_vbq_to_node(struct vb2_queue *vq)
> +{
> +	return container_of(vq, struct mtk_dip_video_device, dev_q.vbq);
> +}
> +
> +static inline struct mtk_dip_dev_buffer *
> +mtk_dip_vb2_buf_to_dev_buf(struct vb2_buffer *vb)
> +{
> +	return container_of(vb, struct mtk_dip_dev_buffer, vbb.vb2_buf);
> +}
> +
> +static inline struct mtk_dip_dev *mtk_dip_hw_to_dev(struct mtk_dip_hw *dip_hw)
> +{
> +	return container_of(dip_hw, struct mtk_dip_dev, dip_hw);
> +}
> +
> +static inline int mtk_dip_buf_is_meta(u32 type)
> +{
> +	return type == V4L2_BUF_TYPE_META_CAPTURE ||
> +		type == V4L2_BUF_TYPE_META_OUTPUT;
> +}
> +
> +static inline int mtk_dip_pipe_get_pipe_from_job_id(int pipe_job_id)
> +{
> +	return (pipe_job_id >> 16) & 0x0000FFFF;
> +}
> +
> +#endif /* _MTK_DIP_DEV_H_ */
> diff --git a/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-hw.h b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-hw.h
> new file mode 100644
> index 000000000000..d813d8b92e8b
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-hw.h
> @@ -0,0 +1,167 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Copyright (C) 2018 MediaTek Inc.
> + * Author: Holmes Chiou <holmes.chiou@mediatek.com>
> + *
> + * This program is free software: you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +
> +#ifndef _MTK_DIP_HW_H_
> +#define _MTK_DIP_HW_H_
> +
> +#include <linux/clk.h>
> +#include "mtk-img-ipi.h"
> +
> +enum STREAM_TYPE_ENUM {
> +	STREAM_UNKNOWN,
> +	STREAM_BITBLT,
> +	STREAM_GPU_BITBLT,
> +	STREAM_DUAL_BITBLT,
> +	STREAM_2ND_BITBLT,
> +	STREAM_ISP_IC,
> +	STREAM_ISP_VR,
> +	STREAM_ISP_ZSD,
> +	STREAM_ISP_IP,
> +	STREAM_ISP_VSS,
> +	STREAM_ISP_ZSD_SLOW,
> +	STREAM_WPE,
> +	STREAM_WPE2,
> +};
> +
> +enum mtk_dip_hw_user_state {
> +	DIP_STATE_INIT	= 0,
> +	DIP_STATE_STREAMON,
> +	DIP_STATE_STREAMOFF
> +};
> +
> +struct mtk_dip_hw_frame_job {
> +	struct img_frameparam fparam;
> +	int sequence;
> +};
> +
> +struct mtk_dip_hw_user_id {
> +	struct list_head list_entry;
> +	u16 id;
> +	u32 num;
> +	u16 state;
> +};
> +
> +struct mtk_dip_hw_subframe {
> +	struct img_addr buffer;
> +	struct sg_table table;
> +	struct img_sw_addr config_data;
> +	struct img_addr tuning_buf;
> +	struct img_sw_addr frameparam;
> +	struct list_head list_entry;
> +};
> +
> +struct mtk_dip_hw_queue {
> +	struct list_head queue;
> +	struct mutex queuelock; /* protect queue and queue_cnt */
> +	u32 queue_cnt;
> +};
> +
> +struct mtk_dip_hw_joblist {
> +	struct list_head queue;
> +	spinlock_t queuelock; /* protect job list */
> +	u32 queue_cnt;
> +};
> +
> +struct mtk_dip_hw_thread {
> +	struct task_struct *thread;
> +	wait_queue_head_t wq;
> +};
> +
> +struct mtk_dip_hw_work {
> +	struct list_head list_entry;
> +	struct img_ipi_frameparam frameparams;
> +	struct mtk_dip_hw_user_id *user_id;
> +};
> +
> +struct mtk_dip_hw_submit_work {
> +	struct work_struct frame_work;
> +	struct mtk_dip_hw *dip_hw;
> +};
> +
> +struct mtk_dip_hw_mdpcb_work {
> +	struct work_struct frame_work;
> +	struct img_ipi_frameparam *frameparams;
> +};
> +
> +struct mtk_dip_hw_clk {
> +	struct clk *img_larb5;
> +	struct clk *img_dip;
> +};
> +
> +enum frame_state {
> +	FRAME_STATE_INIT = 0,
> +	FRAME_STATE_COMPOSING,
> +	FRAME_STATE_RUNNING,
> +	FRAME_STATE_DONE,
> +	FRAME_STATE_STREAMOFF,
> +	FRAME_STATE_ERROR,
> +	FRAME_STATE_HW_TIMEOUT
> +};
> +
> +struct mtk_dip_hw {
> +	struct mtk_dip_hw_clk dip_clk;
> +	struct device *larb_dev;
> +	struct mtk_dip_hw_joblist dip_gcejoblist;
> +	struct mtk_dip_hw_queue dip_freebufferlist;
> +	struct mtk_dip_hw_queue dip_usedbufferlist;
> +	struct mtk_dip_hw_thread dip_runner_thread;
> +	struct mtk_dip_hw_queue dip_useridlist;
> +	struct mtk_dip_hw_queue dip_worklist;
> +	struct workqueue_struct *composer_wq;
> +	struct mtk_dip_hw_submit_work submit_work;
> +	wait_queue_head_t composing_wq;
> +	wait_queue_head_t flushing_wq;
> +	atomic_t num_composing;	/* increase after ipi */
> +	/* increase after calling MDP driver */
> +	atomic_t num_running;
> +	/*MDP/GCE callback workqueue */

Missing space after "/*".

> +	struct workqueue_struct *mdpcb_workqueue;
> +	/* for MDP driver  */
> +	struct platform_device *mdp_pdev;
> +	/* for VPU driver  */
> +	struct platform_device *vpu_pdev;
> +	struct rproc *rproc_handle;
> +	dma_addr_t scp_workingbuf_addr;
> +	/* increase after enqueue */
> +	atomic_t dip_enque_cnt;
> +	/* increase after Stream ON, decrease when Stream OFF */
> +	atomic_t dip_stream_cnt;
> +	/* increase after open, decrease when close */
> +	atomic_t dip_user_cnt;
> +};
> +
> +int mtk_dip_hw_enqueue(struct mtk_dip_hw *dip_hw,
> +		       struct img_ipi_frameparam *frameparams);
> +int mtk_dip_hw_connect(struct mtk_dip_hw *dip_hw);
> +int mtk_dip_hw_disconnect(struct mtk_dip_hw *dip_hw);
> +int mtk_dip_hw_streamon(struct mtk_dip_hw *dip_hw, u16 id);
> +int mtk_dip_hw_streamoff(struct mtk_dip_hw *dip_hw, u16 id);
> +
> +static inline struct mtk_dip_hw_frame_job
> +*mtk_dip_fparam_to_job(struct img_frameparam *fparam)
> +{
> +	return container_of(fparam, struct mtk_dip_hw_frame_job, fparam);
> +}
> +
> +static inline struct mtk_dip_hw_frame_job *
> +mtk_dip_ipi_fparam_to_job(struct img_ipi_frameparam *ipi_fparam)
> +{
> +	return container_of(ipi_fparam,
> +			    struct mtk_dip_hw_frame_job,
> +			    fparam.frameparam);
> +}
> +
> +#endif /* _MTK_DIP_HW_H_ */
> +
> diff --git a/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-smem.c b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-smem.c
> new file mode 100644
> index 000000000000..5456c0b54ad4
> --- /dev/null
> +++ b/drivers/media/platform/mtk-isp/isp_50/dip/mtk_dip-smem.c
> @@ -0,0 +1,322 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2018 MediaTek Inc.
> + * Author: Frederic Chen <frederic.chen@mediatek.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/platform_device.h>
> +#include <linux/of.h>
> +#include <linux/of_fdt.h>
> +#include <linux/of_reserved_mem.h>
> +#include <linux/dma-contiguous.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/slab.h>
> +#include <linux/err.h>
> +#include <linux/iommu.h>
> +#include <asm/cacheflush.h>
> +#include "mtk_dip-smem.h"
> +
> +#define MTK_DIP_SMEM_DEV_NAME "MTK-DIP-SMEM"
> +
> +static struct reserved_mem *dip_reserved_smem;
> +static struct dma_map_ops smem_dma_ops;
> +
> +struct dma_coherent_mem {
> +	void		*virt_base;
> +	dma_addr_t	device_base;
> +	unsigned long	pfn_base;
> +	int		size;
> +	int		flags;
> +	unsigned long	*bitmap;
> +	spinlock_t	spinlock; /* protect dma_coherent_mem member */
> +	bool		use_dev_dma_pfn_offset;
> +};
> +
> +static struct dma_coherent_mem *dev_get_coherent_memory(struct device *dev)
> +{
> +	if (dev && dev->dma_mem)
> +		return dev->dma_mem;
> +	return NULL;
> +}
> +
> +phys_addr_t mtk_dip_smem_iova_to_phys(struct mtk_dip_smem_dev *smem_dev,
> +				      dma_addr_t iova)
> +{
> +		struct iommu_domain *smem_dom;
> +		phys_addr_t addr;
> +		phys_addr_t limit;
> +
> +		if (!smem_dev)
> +			return 0;
> +
> +		smem_dom = iommu_get_domain_for_dev(smem_dev->dev.parent);
> +
> +		if (!smem_dom)
> +			return 0;
> +
> +		addr = iommu_iova_to_phys(smem_dom, iova);
> +
> +		limit = smem_dev->smem_base + smem_dev->smem_size;
> +
> +		if (addr < smem_dev->smem_base || addr >= limit) {
> +			dev_err(&smem_dev->dev,
> +				"Unexpected scp_daddr %pa (must >= %pa and <%pa)\n",
> +				&addr, &smem_dev->smem_base, &limit);
> +			return 0;
> +		}
> +		dev_dbg(&smem_dev->dev, "Pa verifcation pass: %pa(>=%pa, <%pa)\n",
> +			&addr, &smem_dev->smem_base, &limit);
> +		return addr;
> +}
> +
> +/********************************************
> + * MTK DIP SMEM DMA ops *
> + ********************************************/
> +static int mtk_dip_smem_get_sgtable(struct device *dev,
> +				    struct sg_table *sgt,
> +				    void *cpu_addr,
> +				    dma_addr_t dma_addr,
> +				    size_t size, unsigned long attrs)
> +{
> +	struct mtk_dip_smem_dev *smem_dev = dev_get_drvdata(dev);
> +	int n_pages_align;
> +	int size_align;
> +	int page_start;
> +	unsigned long long offset_p;
> +
> +	phys_addr_t paddr = mtk_dip_smem_iova_to_phys(smem_dev, dma_addr);
> +
> +	offset_p = (unsigned long long)paddr -
> +		(unsigned long long)smem_dev->smem_base;
> +
> +	dev_dbg(dev, "%s: dma_addr(%p), cpu_addr(%p), pa(%p), size(%d)\n",
> +		__func__, dma_addr, cpu_addr, paddr, size);

Please use %zd for size as it is a size_t.

> +
> +	size_align = round_up(size, PAGE_SIZE);
> +	n_pages_align = size_align >> PAGE_SHIFT;
> +	page_start = offset_p >> PAGE_SHIFT;
> +
> +	dev_dbg(dev, "%s: page_start(%d), page pa(%p), pa(%p), aligned size(%d)\n",
> +		__func__,
> +		page_start,
> +		page_to_phys(*(smem_dev->smem_pages + page_start)),
> +		paddr,
> +		size_align
> +		);
> +
> +	if (!smem_dev) {
> +		dev_err(dev, "can't get sgtable from smem_dev\n");
> +		return -EINVAL;
> +	}

We already dereference smem_dev above. Should we move this check or simply
remove it?

> +
> +	dev_dbg(dev, "%s: get sgt of the smem: %d pages\n", __func__,
> +		n_pages_align);
> +
> +	return sg_alloc_table_from_pages(sgt,
> +					 smem_dev->smem_pages + page_start,
> +					 n_pages_align,
> +					 0, size_align, GFP_KERNEL);
> +}
> +

<snip>

> +
> -- 
> 2.18.0
> 

Sincerely,
Shik