Hi Tomasz,
On Fri, 2019-09-06 at 18:11 +0800, Jerry-ch Chen wrote:
> From: Jerry-ch Chen <jerry-ch.c...@mediatek.com>
>
> 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 <jerry-ch.c...@mediatek.com>
> ---
> 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 | 148 ++
> drivers/media/platform/mtk-isp/fd/mtk_fd_40.c | 1219 +++++++++++++++++
> include/uapi/linux/mtk-fd-v4l2-controls.h | 69 +
> include/uapi/linux/v4l2-controls.h | 4 +
> 8 files changed, 1468 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
> create mode 100644 include/uapi/linux/mtk-fd-v4l2-controls.h
>
[snip]
> +
> +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;
> +
> + 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);
> +}
> +
> +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);
> + pm_runtime_put((fd->dev));
> + mtk_fd_hw_job_finish(fd, VB2_BUF_STATE_ERROR);
> + }
> + return;
> + case MTK_FD_IPI_CMD_RESET_ACK:
> + 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_hw_disconnect(struct mtk_fd_dev *fd)
> +{
> + fd->fd_stream_count--;
> +
> + if (fd->fd_stream_count == 0) {
> + if (!IS_ERR(fd->rs_dma_buf))
> + mtk_fd_free_dma_handle(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_irq_done);
> + 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), MTK_FD_IPI_SEND_TIMEOUT);
> + if (ret) {
> + pm_runtime_put((fd->dev));
> + mtk_fd_hw_job_finish(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 %d is too small\n");
> + 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 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 %d is too small\n");
> + 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 int mtk_fd_job_abort(struct mtk_fd_dev *fd)
> +{
> + u32 ret;
> +
> + ret = wait_for_completion_timeout(&fd->fd_irq_done,
> + msecs_to_jiffies(MTK_FD_HW_TIMEOUT));
> + /* Reset FD HW */
> + if (!ret) {
> + 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), MTK_FD_IPI_SEND_TIMEOUT))
> + dev_err(fd->dev, "FD Reset HW error\n");
> + return -ETIMEDOUT;
> + }
> + return 0;
> +}
> +
Continue the discussion about job abort in RFC v2,
I think the job_abort callback in v4l2_m2m_ops() might be useful.
ref:
https://elixir.bootlin.com/linux/v5.4-rc2/source/drivers/media/v4l2-core/v4l2-mem2mem.c#L398
https://elixir.bootlin.com/linux/v5.4-rc2/source/include/media/v4l2-mem2mem.h#L43
in drivers/media/v4l2-core/v4l2-mem2mem.c #398 v4l2_m2m_cancel_job()
...
if (m2m_ctx->job_flags & TRANS_RUNNING) {
spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags);
if (m2m_dev->m2m_ops->job_abort)
m2m_dev->m2m_ops->job_abort(m2m_ctx->priv);
dprintk("m2m_ctx %p running, will wait to complete\n", m2m_ctx);
wait_event(m2m_ctx->finished,
!(m2m_ctx->job_flags & TRANS_RUNNING));
} ...
If this operation is set, we might use the v4l2_m2m_cancel_job() when
suspend, and it will do mtk_fd_job_abort() here.
> +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_abort(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);
> +}
> +
[snip]
> +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,
> + },
> +};
> +
[snip]
> +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;
> +
> + 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);
> + fd_param.output_vaddr = (u64)vb2_plane_vaddr(&dst_buf->vb2_buf, 0);
> + 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 = (struct fd_user_output *)fd_param.output_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,
> +};
[snip]
> +
> +static int mtk_fd_suspend(struct device *dev)
> +{
> + struct mtk_fd_dev *fd = dev_get_drvdata(dev);
> +
> + if (pm_runtime_suspended(dev))
> + return 0;
> +
> + if (fd->fd_stream_count)
> + if (mtk_fd_job_abort(fd))
> + mtk_fd_hw_job_finish(fd, VB2_BUF_STATE_ERROR);
> +
To avoid mtk_fd_hw_job_finish() trigger the next job,
I suppose that we could use v4l2_m2m_cancel_job instead of job_abort and
job_finish here.
/**
* v4l2_m2m_cancel_job() - cancel pending jobs for the context
* @m2m_ctx: m2m context with jobs to be canceled
*
* In case of streamoff or release called on any context,
* 1] If the context is currently running, then abort job will be called
* 2] If the context is queued, then the context will be removed from
* the job_queue
*/
or another way,
we may add a flag and implement mtk_fd_job_ready() that reads the flag
if we suspend, we set the flag and do job_abort and job_finish, even if
it try enqueue, it will still not really queue the job, until we reset
the flag in mtk_fd_resume().
how do you think?
> + /* 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__);
> +
> + 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_DESCRIPTION("Mediatek FD driver");
> +MODULE_LICENSE("GPL");
> diff --git a/include/uapi/linux/mtk-fd-v4l2-controls.h
> b/include/uapi/linux/mtk-fd-v4l2-controls.h
> new file mode 100644
> index 000000000000..9b814de05b0c
> --- /dev/null
> +++ b/include/uapi/linux/mtk-fd-v4l2-controls.h
> @@ -0,0 +1,69 @@
> +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
> +//
> +// Copyright (c) 2019 MediaTek Inc.
> +/*
> + * For V4L2_CID_MTK_FD_DETECT_POSE, User can set the desired face direction
> to
> + * be detected for each face angle, there are five face angle and 12
> directions.
> + * Below shows the definition of face angle and face direction,
> + * and a recommended usage of for face detection, the more selected
> directions
> + * the longer HW process time needed.
> + *
> + * 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 face_direction_def {
> + * __u16 MTK_FD_FACE_DIR_0 : 1,
> + * MTK_FD_FACE_DIR_30 : 1,
> + * MTK_FD_FACE_DIR_60 : 1,
> + * MTK_FD_FACE_DIR_90 : 1,
> + * MTK_FD_FACE_DIR_120 : 1,
> + * MTK_FD_FACE_DIR_150 : 1,
> + * MTK_FD_FACE_DIR_180 : 1,
> + * MTK_FD_FACE_DIR_210 : 1,
> + * MTK_FD_FACE_DIR_240 : 1,
> + * MTK_FD_FACE_DIR_270 : 1,
> + * MTK_FD_FACE_DIR_300 : 1,
> + * MTK_FD_FACE_DIR_330 : 1,
> + * : 4;
> + * };
> + *
> + * Sample usage:
> + * u16 face_directions[MTK_FD_FACE_ANGLE_NUM] = {0};
> + *
> + * face_directions[MTK_FD_FACE_FRONT] = 0x3ff;
> + *
> + */
> +
> +#ifndef __UAPI_MTK_FD_V4L2_CONTROLS_H__
> +#define __UAPI_MTK_FD_V4L2_CONTROLS_H__
> +
> +#include <linux/v4l2-controls.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
> +
For these control IDs, I think the following should be remained as chip
specific controls.
V4L2_CID_MTK_FD_SCALE_DOWN_IMG_WIDTH,
V4L2_CID_MTK_FD_SCALE_DOWN_IMG_HEIGHT and V4L2_CID_MTK_FD_SCALE_IMG_NUM
Hope there would be standardizing face detection api that cover the rest
controls: V4L2_CID_MTK_FD_DETECT_POSE, V4L2_CID_MTK_FD_DETECT_SPEED and
V4L2_CID_MTK_FD_DETECTION_MODEL
Would you have any suggestions on how to propose the standard face
detection apis?
Thanks and best regards
Jerry
> +#endif /* __UAPI_MTK_FD_V4L2_CONTROLS_H__ */
> 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 */
