[DKIM] [PATCH v21 4/4] media: platform: mtk-mdp3: add Mediatek MDP3 driver
Laurent Pinchart
laurent.pinchart at ideasonboard.com
Fri Jul 8 01:20:38 PDT 2022
On Fri, Jul 08, 2022 at 10:08:44AM +0200, Hans Verkuil wrote:
> Hi Moudy,
>
> Some comments below:
And one more
> On 7/6/22 09:54, Moudy Ho wrote:
> > This patch adds driver for Mediatek's Media Data Path ver.3 (MDP3).
> > It provides the following functions:
> > color transform, format conversion, resize, crop, rotate, flip
> > and additional image quality enhancement.
> >
> > The MDP3 driver is mainly used for Google Chromebook products to
> > import the new architecture to set the HW settings as shown below:
> > User -> V4L2 framework
> > -> MDP3 driver -> SCP (setting calculations)
> > -> MDP3 driver -> CMDQ (GCE driver) -> HW
> >
> > Each modules' related operation control is sited in mtk-mdp3-comp.c
> > Each modules' register table is defined in file with "mdp_reg_" prefix
> > GCE related API, operation control sited in mtk-mdp3-cmdq.c
> > V4L2 m2m device functions are implemented in mtk-mdp3-m2m.c
> > Probe, power, suspend/resume, system level functions are defined in
> > mtk-mdp3-core.c
> >
> > v4l2-compliance 1.22.1, 32 bits, 32-bit time_t
> >
> > Compliance test for mtk-mdp3 device /dev/video2:
> >
> > Driver Info:
> > Driver name : mtk-mdp3
> > Card type : 14001000.mdp3-rdma0
>
> Card type is expected to be a human readable name, and that's not the case
> here.
>
> > Bus info : platform:mtk-mdp3
>
> <snip>
>
> > diff --git a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c
> > new file mode 100644
> > index 000000000000..9d2b8acc303f
> > --- /dev/null
> > +++ b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c
> > @@ -0,0 +1,769 @@
> > +// SPDX-License-Identifier: GPL-2.0-only
> > +/*
> > + * Copyright (c) 2022 MediaTek Inc.
> > + * Author: Ping-Hsun Wu <ping-hsun.wu at mediatek.com>
> > + */
> > +
> > +#include <linux/platform_device.h>
> > +#include <media/v4l2-ioctl.h>
> > +#include <media/v4l2-event.h>
> > +#include <media/videobuf2-dma-contig.h>
> > +#include "mtk-mdp3-m2m.h"
> > +
> > +static inline struct mdp_m2m_ctx *fh_to_ctx(struct v4l2_fh *fh)
> > +{
> > + return container_of(fh, struct mdp_m2m_ctx, fh);
> > +}
> > +
> > +static inline struct mdp_m2m_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl)
> > +{
> > + return container_of(ctrl->handler, struct mdp_m2m_ctx, ctrl_handler);
> > +}
> > +
> > +static inline struct mdp_frame *ctx_get_frame(struct mdp_m2m_ctx *ctx,
> > + enum v4l2_buf_type type)
> > +{
> > + if (V4L2_TYPE_IS_OUTPUT(type))
> > + return &ctx->curr_param.output;
> > + else
> > + return &ctx->curr_param.captures[0];
> > +}
> > +
> > +static void mdp_m2m_ctx_set_state(struct mdp_m2m_ctx *ctx, u32 state)
> > +{
> > + atomic_or(state, &ctx->curr_param.state);
> > +}
> > +
> > +static bool mdp_m2m_ctx_is_state_set(struct mdp_m2m_ctx *ctx, u32 mask)
> > +{
> > + bool ret;
> > +
> > + ret = ((atomic_read(&ctx->curr_param.state) & mask) == mask);
>
> This can just do 'return' so you can drop the 'ret' variable.
>
> > +
> > + return ret;
> > +}
> > +
> > +static void mdp_m2m_process_done(void *priv, int vb_state)
> > +{
> > + struct mdp_m2m_ctx *ctx = priv;
> > + struct vb2_v4l2_buffer *src_vbuf, *dst_vbuf;
> > +
> > + src_vbuf = (struct vb2_v4l2_buffer *)
> > + v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
> > + dst_vbuf = (struct vb2_v4l2_buffer *)
> > + v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
> > + ctx->curr_param.frame_no = ctx->frame_count[MDP_M2M_SRC];
> > + src_vbuf->sequence = ctx->frame_count[MDP_M2M_SRC]++;
> > + dst_vbuf->sequence = ctx->frame_count[MDP_M2M_DST]++;
> > + v4l2_m2m_buf_copy_metadata(src_vbuf, dst_vbuf, true);
> > +
> > + v4l2_m2m_buf_done(src_vbuf, vb_state);
> > + v4l2_m2m_buf_done(dst_vbuf, vb_state);
> > + v4l2_m2m_job_finish(ctx->mdp_dev->m2m_dev, ctx->m2m_ctx);
> > +}
> > +
> > +static void mdp_m2m_device_run(void *priv)
> > +{
> > + struct mdp_m2m_ctx *ctx = priv;
> > + struct mdp_frame *frame;
> > + struct vb2_v4l2_buffer *src_vb, *dst_vb;
> > + struct img_ipi_frameparam param = {0};
> > + struct mdp_cmdq_param task = {0};
>
> Just use '= {}', it's cleaner.
>
> > + enum vb2_buffer_state vb_state = VB2_BUF_STATE_ERROR;
> > + int ret;
> > +
> > + if (mdp_m2m_ctx_is_state_set(ctx, MDP_M2M_CTX_ERROR)) {
> > + dev_err(&ctx->mdp_dev->pdev->dev,
> > + "mdp_m2m_ctx is in error state\n");
> > + goto worker_end;
> > + }
> > +
> > + param.frame_no = ctx->curr_param.frame_no;
> > + param.type = ctx->curr_param.type;
> > + param.num_inputs = 1;
> > + param.num_outputs = 1;
> > +
> > + frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
> > + src_vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
> > + mdp_set_src_config(¶m.inputs[0], frame, &src_vb->vb2_buf);
> > +
> > + frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > + dst_vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
> > + mdp_set_dst_config(¶m.outputs[0], frame, &dst_vb->vb2_buf);
> > +
> > + ret = mdp_vpu_process(&ctx->vpu, ¶m);
> > + if (ret) {
> > + dev_err(&ctx->mdp_dev->pdev->dev,
> > + "VPU MDP process failed: %d\n", ret);
> > + goto worker_end;
> > + }
> > +
> > + task.config = ctx->vpu.config;
> > + task.param = ¶m;
> > + task.composes[0] = &frame->compose;
> > + task.cmdq_cb = NULL;
> > + task.cb_data = NULL;
> > + task.mdp_ctx = ctx;
> > +
> > + ret = mdp_cmdq_send(ctx->mdp_dev, &task);
> > + if (ret) {
> > + dev_err(&ctx->mdp_dev->pdev->dev,
> > + "CMDQ sendtask failed: %d\n", ret);
> > + goto worker_end;
> > + }
> > +
> > + return;
> > +
> > +worker_end:
> > + mdp_m2m_process_done(ctx, vb_state);
> > +}
> > +
> > +static int mdp_m2m_start_streaming(struct vb2_queue *q, unsigned int count)
> > +{
> > + struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(q);
> > +
> > + ctx->frame_count[MDP_M2M_SRC] = 0;
> > + ctx->frame_count[MDP_M2M_DST] = 0;
>
> Don't set both, check which queue it is first.
>
> > +
> > + return 0;
> > +}
> > +
> > +static struct vb2_v4l2_buffer *mdp_m2m_buf_remove(struct mdp_m2m_ctx *ctx,
> > + unsigned int type)
> > +{
> > + if (V4L2_TYPE_IS_OUTPUT(type))
> > + return (struct vb2_v4l2_buffer *)
> > + v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
> > + else
> > + return (struct vb2_v4l2_buffer *)
> > + v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
> > +}
> > +
> > +static void mdp_m2m_stop_streaming(struct vb2_queue *q)
> > +{
> > + struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(q);
> > + struct vb2_v4l2_buffer *vb;
> > +
> > + vb = mdp_m2m_buf_remove(ctx, q->type);
> > + while (vb) {
> > + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR);
> > + vb = mdp_m2m_buf_remove(ctx, q->type);
> > + }
> > +}
> > +
> > +static int mdp_m2m_queue_setup(struct vb2_queue *q,
> > + unsigned int *num_buffers,
> > + unsigned int *num_planes, unsigned int sizes[],
> > + struct device *alloc_devs[])
> > +{
> > + struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(q);
> > + struct v4l2_pix_format_mplane *pix_mp;
> > + struct device *dev = &ctx->mdp_dev->pdev->dev;
> > + u32 i;
> > +
> > + pix_mp = &ctx_get_frame(ctx, q->type)->format.fmt.pix_mp;
> > +
> > + /* from VIDIOC_CREATE_BUFS */
> > + if (*num_planes) {
> > + if (*num_planes != pix_mp->num_planes)
> > + return -EINVAL;
> > + for (i = 0; i < pix_mp->num_planes; ++i)
> > + if (sizes[i] < pix_mp->plane_fmt[i].sizeimage)
> > + return -EINVAL;
> > + } else {/* from VIDIOC_REQBUFS */
> > + *num_planes = pix_mp->num_planes;
> > + for (i = 0; i < pix_mp->num_planes; ++i)
> > + sizes[i] = pix_mp->plane_fmt[i].sizeimage;
> > + }
> > +
> > + dev_info(dev, "[%d] type:%d, planes:%u, buffers:%u, size:%u,%u,%u",
>
> This should be dropped or changed to dev_dbg. You don't want logging
> when doing normal things, that will just spam the kernel log.
>
> > + ctx->id, q->type, *num_planes, *num_buffers,
> > + sizes[0], sizes[1], sizes[2]);
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_buf_prepare(struct vb2_buffer *vb)
> > +{
> > + struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
> > + struct v4l2_pix_format_mplane *pix_mp;
> > + struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb);
> > + u32 i;
> > +
> > + v4l2_buf->field = V4L2_FIELD_NONE;
> > +
> > + if (!V4L2_TYPE_IS_OUTPUT(vb->type)) {
> > + pix_mp = &ctx_get_frame(ctx, vb->type)->format.fmt.pix_mp;
> > + for (i = 0; i < pix_mp->num_planes; ++i) {
> > + vb2_set_plane_payload(vb, i,
> > + pix_mp->plane_fmt[i].sizeimage);
> > + }
> > + }
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_buf_out_validate(struct vb2_buffer *vb)
> > +{
> > + struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb);
> > +
> > + v4l2_buf->field = V4L2_FIELD_NONE;
> > +
> > + return 0;
> > +}
> > +
> > +static void mdp_m2m_buf_queue(struct vb2_buffer *vb)
> > +{
> > + struct mdp_m2m_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
> > + struct vb2_v4l2_buffer *v4l2_buf = to_vb2_v4l2_buffer(vb);
> > +
> > + v4l2_buf->field = V4L2_FIELD_NONE;
> > +
> > + v4l2_m2m_buf_queue(ctx->m2m_ctx, to_vb2_v4l2_buffer(vb));
> > +}
> > +
> > +static const struct vb2_ops mdp_m2m_qops = {
> > + .queue_setup = mdp_m2m_queue_setup,
> > + .wait_prepare = vb2_ops_wait_prepare,
> > + .wait_finish = vb2_ops_wait_finish,
> > + .buf_prepare = mdp_m2m_buf_prepare,
> > + .start_streaming = mdp_m2m_start_streaming,
> > + .stop_streaming = mdp_m2m_stop_streaming,
> > + .buf_queue = mdp_m2m_buf_queue,
> > + .buf_out_validate = mdp_m2m_buf_out_validate,
> > +};
> > +
> > +static int mdp_m2m_querycap(struct file *file, void *fh,
> > + struct v4l2_capability *cap)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > +
> > + strscpy(cap->driver, MDP_MODULE_NAME, sizeof(cap->driver));
> > + strscpy(cap->card, ctx->mdp_dev->pdev->name, sizeof(cap->card));
>
> As mentioned at the top, this is not a suitable name for cap->card.
>
> > + strscpy(cap->bus_info, "platform:mtk-mdp3", sizeof(cap->bus_info));
And don't override bus_info, the value isn't right. The V4L2 core should
do the right thing for platform devices now.
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_enum_fmt_mplane(struct file *file, void *fh,
> > + struct v4l2_fmtdesc *f)
> > +{
> > + return mdp_enum_fmt_mplane(f);
> > +}
> > +
> > +static int mdp_m2m_g_fmt_mplane(struct file *file, void *fh,
> > + struct v4l2_format *f)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > + struct mdp_frame *frame;
> > + struct v4l2_pix_format_mplane *pix_mp;
> > + struct device *dev = &ctx->mdp_dev->pdev->dev;
> > +
> > + frame = ctx_get_frame(ctx, f->type);
> > + *f = frame->format;
> > + pix_mp = &f->fmt.pix_mp;
> > + pix_mp->colorspace = ctx->curr_param.colorspace;
> > + pix_mp->xfer_func = ctx->curr_param.xfer_func;
> > + pix_mp->ycbcr_enc = ctx->curr_param.ycbcr_enc;
> > + pix_mp->quantization = ctx->curr_param.quant;
> > +
> > + dev_info(dev, "[%d] type:%d, frame:%ux%u colorspace=%d", ctx->id, f->type,
> > + f->fmt.pix_mp.width, f->fmt.pix_mp.height,
> > + f->fmt.pix_mp.colorspace);
>
> Drop this, you're returning this info to userspace anyway, so why spam the
> kernel log?
>
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_s_fmt_mplane(struct file *file, void *fh,
> > + struct v4l2_format *f)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > + struct mdp_frame *frame = ctx_get_frame(ctx, f->type);
> > + struct mdp_frame *capture;
> > + const struct mdp_format *fmt;
> > + struct vb2_queue *vq;
> > + struct device *dev = &ctx->mdp_dev->pdev->dev;
> > +
> > + dev_info(dev, "[%d] type:%d", ctx->id, f->type);
>
> dev_dbg. If dev_info is used elsewhere in similar situations, then replace that
> with dev_dbg as well. Regular usage of this driver must not produce kernel logging.
>
> > +
> > + fmt = mdp_try_fmt_mplane(f, &ctx->curr_param, ctx->id);
> > + if (!fmt) {
> > + dev_info(dev, "[%d] try_fmt failed, type:%d", ctx->id, f->type);
>
> Drop this, the error code says enough.
>
> > + return -EINVAL;
> > + }
> > +
> > + vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
> > + if (vb2_is_streaming(vq)) {
>
> This must be vb2_is_busy(): changing formats is prohibited once buffers are
> allocated (vb2_is_busy() is true in that case).
>
> > + dev_info(&ctx->mdp_dev->pdev->dev, "Queue %d busy\n", f->type);
>
> Drop this, the error code says enough.
>
> > + return -EBUSY;
> > + }
> > +
> > + frame->format = *f;
> > + frame->mdp_fmt = fmt;
> > + frame->ycbcr_prof = mdp_map_ycbcr_prof_mplane(f, fmt->mdp_color);
> > + frame->usage = V4L2_TYPE_IS_OUTPUT(f->type) ?
> > + MDP_BUFFER_USAGE_HW_READ : MDP_BUFFER_USAGE_MDP;
> > +
> > + capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > + if (V4L2_TYPE_IS_OUTPUT(f->type)) {
> > + capture->crop.c.left = 0;
> > + capture->crop.c.top = 0;
> > + capture->crop.c.width = f->fmt.pix_mp.width;
> > + capture->crop.c.height = f->fmt.pix_mp.height;
> > + ctx->curr_param.colorspace = f->fmt.pix_mp.colorspace;
> > + ctx->curr_param.ycbcr_enc = f->fmt.pix_mp.ycbcr_enc;
> > + ctx->curr_param.quant = f->fmt.pix_mp.quantization;
> > + ctx->curr_param.xfer_func = f->fmt.pix_mp.xfer_func;
> > + } else {
> > + capture->compose.left = 0;
> > + capture->compose.top = 0;
> > + capture->compose.width = f->fmt.pix_mp.width;
> > + capture->compose.height = f->fmt.pix_mp.height;
> > + }
> > +
> > + ctx->frame_count[MDP_M2M_SRC] = 0;
> > + ctx->frame_count[MDP_M2M_DST] = 0;
>
> Changing the format doesn't mean you need to zero this. Just drop these two
> line.
>
> > +
> > + dev_info(dev, "[%d] type:%d, frame:%ux%u", ctx->id, f->type,
> > + f->fmt.pix_mp.width, f->fmt.pix_mp.height);
>
> Drop this.
>
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_try_fmt_mplane(struct file *file, void *fh,
> > + struct v4l2_format *f)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > +
> > + if (!mdp_try_fmt_mplane(f, &ctx->curr_param, ctx->id))
> > + return -EINVAL;
> > +
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_streamon(struct file *file, void *fh,
> > + enum v4l2_buf_type type)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > + struct mdp_frame *capture;
> > + int ret;
> > + bool out_streaming, cap_streaming;
> > +
> > + capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > + out_streaming = ctx->m2m_ctx->out_q_ctx.q.streaming;
> > + cap_streaming = ctx->m2m_ctx->cap_q_ctx.q.streaming;
>
> Use vb2_is_streaming() rather than accessing q.streaming directly.
>
> > +
> > + /* Check to see if scaling ratio is within supported range */
> > + if ((V4L2_TYPE_IS_OUTPUT(type) && cap_streaming) ||
> > + (!V4L2_TYPE_IS_OUTPUT(type) && out_streaming)) {
> > + ret = mdp_check_scaling_ratio(&capture->crop.c,
> > + &capture->compose,
> > + capture->rotation,
> > + ctx->curr_param.limit);
> > + if (ret) {
> > + dev_info(&ctx->mdp_dev->pdev->dev,
> > + "Out of scaling range\n");
> > + return ret;
> > + }
> > + }
> > +
> > + if (!mdp_m2m_ctx_is_state_set(ctx, MDP_VPU_INIT)) {
> > + ret = mdp_vpu_get_locked(ctx->mdp_dev);
> > + if (ret)
> > + return ret;
> > +
> > + ret = mdp_vpu_ctx_init(&ctx->vpu, &ctx->mdp_dev->vpu,
> > + MDP_DEV_M2M);
> > + if (ret) {
> > + dev_err(&ctx->mdp_dev->pdev->dev,
> > + "VPU init failed %d\n", ret);
> > + return -EINVAL;
> > + }
> > + mdp_m2m_ctx_set_state(ctx, MDP_VPU_INIT);
> > + }
> > +
> > + return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
> > +}
>
> There really is no reason to override streamon. You can also do this in
> start_streaming(). I recommend moving these tests there. Internally
> streamon() will call start_streaming(), so any error you return in that
> callback function will be the error return of the streamon as well.
>
> > +
> > +static int mdp_m2m_g_selection(struct file *file, void *fh,
> > + struct v4l2_selection *s)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > + struct mdp_frame *frame;
> > + struct device *dev = &ctx->mdp_dev->pdev->dev;
> > + bool valid = false;
> > +
> > + if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> > + valid = mdp_target_is_crop(s->target);
> > + else if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
> > + valid = mdp_target_is_compose(s->target);
> > +
> > + if (!valid) {
> > + dev_err(dev, "[%s:%d] invalid type:%u target:%u", __func__, ctx->id,
> > + s->type, s->target);
>
> Drop this. User errors should never cause spamming in the kernel log.
>
> Please check your code: you can use dev_dbg to help debugging, but dev_info
> should be used very sparingly (typically only in probe() and remove()), and
> dev_warn/err only for hardware/driver warnings/errors, and never due to
> userspace inputs.
>
> > + return -EINVAL;
> > + }
> > +
> > + switch (s->target) {
> > + case V4L2_SEL_TGT_CROP:
> > + if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
> > + frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > + s->r = frame->crop.c;
> > + return 0;
> > + }
>
> It's easier to read if you swap the tests:
>
> if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
> return -EINVAL;
> frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> s->r = frame->crop.c;
> return 0;
>
> Same below.
>
> > + break;
> > + case V4L2_SEL_TGT_COMPOSE:
> > + if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
> > + frame = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > + s->r = frame->compose;
> > + return 0;
> > + }
> > + break;
> > + case V4L2_SEL_TGT_CROP_DEFAULT:
> > + case V4L2_SEL_TGT_CROP_BOUNDS:
> > + if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
> > + frame = ctx_get_frame(ctx, s->type);
> > + s->r.left = 0;
> > + s->r.top = 0;
> > + s->r.width = frame->format.fmt.pix_mp.width;
> > + s->r.height = frame->format.fmt.pix_mp.height;
> > + return 0;
> > + }
> > + break;
> > + case V4L2_SEL_TGT_COMPOSE_DEFAULT:
> > + case V4L2_SEL_TGT_COMPOSE_BOUNDS:
> > + if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
> > + frame = ctx_get_frame(ctx, s->type);
> > + s->r.left = 0;
> > + s->r.top = 0;
> > + s->r.width = frame->format.fmt.pix_mp.width;
> > + s->r.height = frame->format.fmt.pix_mp.height;
> > + return 0;
> > + }
> > + break;
> > + }
> > + return -EINVAL;
> > +}
> > +
> > +static int mdp_m2m_s_selection(struct file *file, void *fh,
> > + struct v4l2_selection *s)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(fh);
> > + struct mdp_frame *frame = ctx_get_frame(ctx, s->type);
> > + struct mdp_frame *capture;
> > + struct v4l2_rect r;
> > + struct device *dev = &ctx->mdp_dev->pdev->dev;
> > + bool valid = false;
> > + int ret;
> > +
> > + if (s->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> > + valid = (s->target == V4L2_SEL_TGT_CROP);
> > + else if (s->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
> > + valid = (s->target == V4L2_SEL_TGT_COMPOSE);
> > +
> > + if (!valid) {
> > + dev_err(dev, "[%s:%d] invalid type:%u target:%u", __func__, ctx->id,
> > + s->type, s->target);
> > + return -EINVAL;
> > + }
> > +
> > + ret = mdp_try_crop(ctx, &r, s, frame);
> > + if (ret)
> > + return ret;
> > + capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > +
> > + if (mdp_target_is_crop(s->target))
> > + capture->crop.c = r;
> > + else
> > + capture->compose = r;
> > +
> > + s->r = r;
> > + memset(s->reserved, 0, sizeof(s->reserved));
>
> No need for this memset, the v4l2 core will clear this for you.
>
> > +
> > + ctx->frame_count[MDP_M2M_SRC] = 0;
> > + ctx->frame_count[MDP_M2M_DST] = 0;
>
> Drop this!
>
> > + return 0;
> > +}
> > +
> > +static const struct v4l2_ioctl_ops mdp_m2m_ioctl_ops = {
> > + .vidioc_querycap = mdp_m2m_querycap,
> > + .vidioc_enum_fmt_vid_cap = mdp_m2m_enum_fmt_mplane,
> > + .vidioc_enum_fmt_vid_out = mdp_m2m_enum_fmt_mplane,
> > + .vidioc_g_fmt_vid_cap_mplane = mdp_m2m_g_fmt_mplane,
> > + .vidioc_g_fmt_vid_out_mplane = mdp_m2m_g_fmt_mplane,
> > + .vidioc_s_fmt_vid_cap_mplane = mdp_m2m_s_fmt_mplane,
> > + .vidioc_s_fmt_vid_out_mplane = mdp_m2m_s_fmt_mplane,
> > + .vidioc_try_fmt_vid_cap_mplane = mdp_m2m_try_fmt_mplane,
> > + .vidioc_try_fmt_vid_out_mplane = mdp_m2m_try_fmt_mplane,
> > + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
> > + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
> > + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
> > + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
> > + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
> > + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
> > + .vidioc_streamon = mdp_m2m_streamon,
> > + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
> > + .vidioc_g_selection = mdp_m2m_g_selection,
> > + .vidioc_s_selection = mdp_m2m_s_selection,
> > + .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
> > + .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
> > +};
> > +
> > +static int mdp_m2m_queue_init(void *priv,
> > + struct vb2_queue *src_vq,
> > + struct vb2_queue *dst_vq)
> > +{
> > + struct mdp_m2m_ctx *ctx = priv;
> > + int ret;
> > +
> > + src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
> > + src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
> > + src_vq->ops = &mdp_m2m_qops;
> > + src_vq->mem_ops = &vb2_dma_contig_memops;
> > + src_vq->drv_priv = ctx;
> > + src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
> > + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
> > + src_vq->dev = &ctx->mdp_dev->pdev->dev;
> > + src_vq->lock = &ctx->ctx_lock;
> > +
> > + ret = vb2_queue_init(src_vq);
> > + if (ret)
> > + return ret;
> > +
> > + dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> > + dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
> > + dst_vq->ops = &mdp_m2m_qops;
> > + dst_vq->mem_ops = &vb2_dma_contig_memops;
> > + dst_vq->drv_priv = ctx;
> > + dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
> > + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
> > + dst_vq->dev = &ctx->mdp_dev->pdev->dev;
> > + dst_vq->lock = &ctx->ctx_lock;
> > +
> > + return vb2_queue_init(dst_vq);
> > +}
> > +
> > +static int mdp_m2m_s_ctrl(struct v4l2_ctrl *ctrl)
> > +{
> > + struct mdp_m2m_ctx *ctx = ctrl_to_ctx(ctrl);
> > + struct mdp_frame *capture;
> > +
> > + if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
> > + return 0;
>
> Why this test? As far as I can tell this flag is never set, so there
> is no need to check against it.
>
> > +
> > + capture = ctx_get_frame(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> > + switch (ctrl->id) {
> > + case V4L2_CID_HFLIP:
> > + capture->hflip = ctrl->val;
> > + break;
> > + case V4L2_CID_VFLIP:
> > + capture->vflip = ctrl->val;
> > + break;
> > + case V4L2_CID_ROTATE:
> > + capture->rotation = ctrl->val;
> > + break;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static const struct v4l2_ctrl_ops mdp_m2m_ctrl_ops = {
> > + .s_ctrl = mdp_m2m_s_ctrl,
> > +};
> > +
> > +static int mdp_m2m_ctrls_create(struct mdp_m2m_ctx *ctx)
> > +{
> > + v4l2_ctrl_handler_init(&ctx->ctrl_handler, MDP_MAX_CTRLS);
> > + ctx->ctrls.hflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,
> > + &mdp_m2m_ctrl_ops, V4L2_CID_HFLIP,
> > + 0, 1, 1, 0);
> > + ctx->ctrls.vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,
> > + &mdp_m2m_ctrl_ops, V4L2_CID_VFLIP,
> > + 0, 1, 1, 0);
> > + ctx->ctrls.rotate = v4l2_ctrl_new_std(&ctx->ctrl_handler,
> > + &mdp_m2m_ctrl_ops,
> > + V4L2_CID_ROTATE, 0, 270, 90, 0);
> > +
> > + if (ctx->ctrl_handler.error) {
> > + int err = ctx->ctrl_handler.error;
> > +
> > + v4l2_ctrl_handler_free(&ctx->ctrl_handler);
> > + dev_err(&ctx->mdp_dev->pdev->dev,
> > + "Failed to register controls\n");
> > + return err;
> > + }
> > + return 0;
> > +}
> > +
> > +static int mdp_m2m_open(struct file *file)
> > +{
> > + struct video_device *vdev = video_devdata(file);
> > + struct mdp_dev *mdp = video_get_drvdata(vdev);
> > + struct mdp_m2m_ctx *ctx;
> > + struct device *dev = &mdp->pdev->dev;
> > + int ret;
> > + struct v4l2_format default_format;
>
> Just add '= {}' to avoid the memset later on.
>
> > +
> > + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
> > + if (!ctx)
> > + return -ENOMEM;
> > +
> > + if (mutex_lock_interruptible(&mdp->m2m_lock)) {
> > + ret = -ERESTARTSYS;
> > + goto err_free_ctx;
> > + }
> > +
> > + ctx->id = ida_alloc(&mdp->mdp_ida, GFP_KERNEL);
> > + ctx->mdp_dev = mdp;
> > +
> > + v4l2_fh_init(&ctx->fh, vdev);
> > + vdev->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
>
> This doesn't belong in open(). It is already done when the video device is registered.
>
> > + file->private_data = &ctx->fh;
> > + ret = mdp_m2m_ctrls_create(ctx);
> > + if (ret)
> > + goto err_exit_fh;
> > +
> > + /* Use separate control handler per file handle */
> > + ctx->fh.ctrl_handler = &ctx->ctrl_handler;
> > + v4l2_fh_add(&ctx->fh);
> > +
> > + mutex_init(&ctx->ctx_lock);
> > + ctx->m2m_ctx = v4l2_m2m_ctx_init(mdp->m2m_dev, ctx, mdp_m2m_queue_init);
> > + if (IS_ERR(ctx->m2m_ctx)) {
> > + dev_err(dev, "Failed to initialize m2m context\n");
> > + ret = PTR_ERR(ctx->m2m_ctx);
> > + goto err_release_handler;
> > + }
> > + ctx->fh.m2m_ctx = ctx->m2m_ctx;
> > +
> > + ctx->curr_param.ctx = ctx;
> > + ret = mdp_frameparam_init(&ctx->curr_param);
> > + if (ret) {
> > + dev_err(dev, "Failed to initialize mdp parameter\n");
> > + goto err_release_m2m_ctx;
> > + }
> > +
> > + mutex_unlock(&mdp->m2m_lock);
> > +
> > + /* Default format */
> > + memset(&default_format, 0, sizeof(default_format));
>
> This can be dropped if default_format is inited with = {}.
>
> > + default_format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
> > + default_format.fmt.pix_mp.width = 32;
> > + default_format.fmt.pix_mp.height = 32;
> > + default_format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_YUV420M;
> > + mdp_m2m_s_fmt_mplane(file, &ctx->fh, &default_format);
> > + default_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> > + mdp_m2m_s_fmt_mplane(file, &ctx->fh, &default_format);
> > +
> > + dev_dbg(dev, "%s:[%d]", __func__, ctx->id);
> > +
> > + return 0;
> > +
> > +err_release_m2m_ctx:
> > + v4l2_m2m_ctx_release(ctx->m2m_ctx);
> > +err_release_handler:
> > + v4l2_ctrl_handler_free(&ctx->ctrl_handler);
> > + v4l2_fh_del(&ctx->fh);
> > +err_exit_fh:
> > + v4l2_fh_exit(&ctx->fh);
> > + mutex_unlock(&mdp->m2m_lock);
> > +err_free_ctx:
> > + kfree(ctx);
> > +
> > + return ret;
> > +}
> > +
> > +static int mdp_m2m_release(struct file *file)
> > +{
> > + struct mdp_m2m_ctx *ctx = fh_to_ctx(file->private_data);
> > + struct mdp_dev *mdp = video_drvdata(file);
> > + struct device *dev = &mdp->pdev->dev;
> > +
> > + mutex_lock(&mdp->m2m_lock);
> > + v4l2_m2m_ctx_release(ctx->m2m_ctx);
> > + if (mdp_m2m_ctx_is_state_set(ctx, MDP_VPU_INIT)) {
> > + mdp_vpu_ctx_deinit(&ctx->vpu);
> > + mdp_vpu_put_locked(mdp);
> > + }
> > +
> > + v4l2_ctrl_handler_free(&ctx->ctrl_handler);
> > + v4l2_fh_del(&ctx->fh);
> > + v4l2_fh_exit(&ctx->fh);
> > + ida_free(&mdp->mdp_ida, ctx->id);
> > + mutex_unlock(&mdp->m2m_lock);
> > +
> > + dev_dbg(dev, "%s:[%d]", __func__, ctx->id);
> > + kfree(ctx);
> > +
> > + return 0;
> > +}
> > +
> > +static const struct v4l2_file_operations mdp_m2m_fops = {
> > + .owner = THIS_MODULE,
> > + .poll = v4l2_m2m_fop_poll,
> > + .unlocked_ioctl = video_ioctl2,
> > + .mmap = v4l2_m2m_fop_mmap,
> > + .open = mdp_m2m_open,
> > + .release = mdp_m2m_release,
> > +};
> > +
> > +static const struct v4l2_m2m_ops mdp_m2m_ops = {
> > + .device_run = mdp_m2m_device_run,
> > +};
> > +
> > +int mdp_m2m_device_register(struct mdp_dev *mdp)
> > +{
> > + struct device *dev = &mdp->pdev->dev;
> > + int ret = 0;
> > +
> > + mdp->m2m_vdev = video_device_alloc();
> > + if (!mdp->m2m_vdev) {
> > + dev_err(dev, "Failed to allocate video device\n");
> > + ret = -ENOMEM;
> > + goto err_video_alloc;
> > + }
> > + mdp->m2m_vdev->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE |
> > + V4L2_CAP_STREAMING;
> > + mdp->m2m_vdev->fops = &mdp_m2m_fops;
> > + mdp->m2m_vdev->ioctl_ops = &mdp_m2m_ioctl_ops;
> > + mdp->m2m_vdev->release = mdp_video_device_release;
> > + mdp->m2m_vdev->lock = &mdp->m2m_lock;
> > + mdp->m2m_vdev->vfl_dir = VFL_DIR_M2M;
> > + mdp->m2m_vdev->v4l2_dev = &mdp->v4l2_dev;
> > + snprintf(mdp->m2m_vdev->name, sizeof(mdp->m2m_vdev->name), "%s:m2m",
> > + MDP_MODULE_NAME);
> > + video_set_drvdata(mdp->m2m_vdev, mdp);
> > +
> > + mdp->m2m_dev = v4l2_m2m_init(&mdp_m2m_ops);
> > + if (IS_ERR(mdp->m2m_dev)) {
> > + dev_err(dev, "Failed to initialize v4l2-m2m device\n");
> > + ret = PTR_ERR(mdp->m2m_dev);
> > + goto err_m2m_init;
> > + }
> > +
> > + ret = video_register_device(mdp->m2m_vdev, VFL_TYPE_VIDEO, 2);
>
> Why 2? Just use -1 to pick the first free device number.
>
> > + if (ret) {
> > + dev_err(dev, "Failed to register video device\n");
> > + goto err_video_register;
> > + }
> > +
> > + v4l2_info(&mdp->v4l2_dev, "Driver registered as /dev/video%d",
> > + mdp->m2m_vdev->num);
> > + return 0;
> > +
> > +err_video_register:
> > + v4l2_m2m_release(mdp->m2m_dev);
> > +err_m2m_init:
> > + video_device_release(mdp->m2m_vdev);
> > +err_video_alloc:
> > +
> > + return ret;
> > +}
> > +
> > +void mdp_m2m_device_unregister(struct mdp_dev *mdp)
> > +{
> > + video_unregister_device(mdp->m2m_vdev);
> > +}
> > +
> > +void mdp_m2m_job_finish(struct mdp_m2m_ctx *ctx)
> > +{
> > + enum vb2_buffer_state vb_state = VB2_BUF_STATE_DONE;
> > +
> > + mdp_m2m_process_done(ctx, vb_state);
> > +}
> > diff --git a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.h b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.h
> > new file mode 100644
> > index 000000000000..61ddbaf1bf13
> > --- /dev/null
> > +++ b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.h
> > @@ -0,0 +1,48 @@
> > +/* SPDX-License-Identifier: GPL-2.0-only */
> > +/*
> > + * Copyright (c) 2022 MediaTek Inc.
> > + * Author: Ping-Hsun Wu <ping-hsun.wu at mediatek.com>
> > + */
> > +
> > +#ifndef __MTK_MDP3_M2M_H__
> > +#define __MTK_MDP3_M2M_H__
> > +
> > +#include <media/v4l2-ctrls.h>
> > +#include "mtk-mdp3-core.h"
> > +#include "mtk-mdp3-vpu.h"
> > +#include "mtk-mdp3-regs.h"
> > +
> > +#define MDP_MAX_CTRLS 10
> > +
> > +enum {
> > + MDP_M2M_SRC = 0,
> > + MDP_M2M_DST = 1,
> > + MDP_M2M_MAX,
> > +};
> > +
> > +struct mdp_m2m_ctrls {
> > + struct v4l2_ctrl *hflip;
> > + struct v4l2_ctrl *vflip;
> > + struct v4l2_ctrl *rotate;
> > +};
> > +
> > +struct mdp_m2m_ctx {
> > + u32 id;
> > + struct mdp_dev *mdp_dev;
> > + struct v4l2_fh fh;
> > + struct v4l2_ctrl_handler ctrl_handler;
> > + struct mdp_m2m_ctrls ctrls;
> > + struct v4l2_m2m_ctx *m2m_ctx;
> > + struct mdp_vpu_ctx vpu;
> > + u32 frame_count[MDP_M2M_MAX];
> > +
> > + struct mdp_frameparam curr_param;
> > + /* synchronization protect for mdp m2m context */
> > + struct mutex ctx_lock;
> > +};
> > +
> > +int mdp_m2m_device_register(struct mdp_dev *mdp);
> > +void mdp_m2m_device_unregister(struct mdp_dev *mdp);
> > +void mdp_m2m_job_finish(struct mdp_m2m_ctx *ctx);
> > +
> > +#endif /* __MTK_MDP3_M2M_H__ */
> > diff --git a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c
> > new file mode 100644
> > index 000000000000..18874eb7851c
> > --- /dev/null
> > +++ b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c
> > @@ -0,0 +1,742 @@
> > +// SPDX-License-Identifier: GPL-2.0-only
> > +/*
> > + * Copyright (c) 2022 MediaTek Inc.
> > + * Author: Ping-Hsun Wu <ping-hsun.wu at mediatek.com>
> > + */
> > +
> > +#include <media/v4l2-common.h>
> > +#include <media/videobuf2-v4l2.h>
> > +#include <media/videobuf2-dma-contig.h>
> > +#include "mtk-mdp3-core.h"
> > +#include "mtk-mdp3-regs.h"
> > +#include "mtk-mdp3-m2m.h"
> > +
> > +/*
> > + * All 10-bit related formats are not added in the basic format list,
> > + * please add the corresponding format settings before use.
> > + */
> > +static const struct mdp_format mdp_formats[] = {
> > + {
> > + .pixelformat = V4L2_PIX_FMT_GREY,
> > + .mdp_color = MDP_COLOR_GREY,
> > + .depth = { 8 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_RGB565X,
> > + .mdp_color = MDP_COLOR_BGR565,
> > + .depth = { 16 },
> > + .row_depth = { 16 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_RGB565,
> > + .mdp_color = MDP_COLOR_RGB565,
> > + .depth = { 16 },
> > + .row_depth = { 16 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_RGB24,
> > + .mdp_color = MDP_COLOR_RGB888,
> > + .depth = { 24 },
> > + .row_depth = { 24 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_BGR24,
> > + .mdp_color = MDP_COLOR_BGR888,
> > + .depth = { 24 },
> > + .row_depth = { 24 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_ABGR32,
> > + .mdp_color = MDP_COLOR_BGRA8888,
> > + .depth = { 32 },
> > + .row_depth = { 32 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_ARGB32,
> > + .mdp_color = MDP_COLOR_ARGB8888,
> > + .depth = { 32 },
> > + .row_depth = { 32 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_UYVY,
> > + .mdp_color = MDP_COLOR_UYVY,
> > + .depth = { 16 },
> > + .row_depth = { 16 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_VYUY,
> > + .mdp_color = MDP_COLOR_VYUY,
> > + .depth = { 16 },
> > + .row_depth = { 16 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_YUYV,
> > + .mdp_color = MDP_COLOR_YUYV,
> > + .depth = { 16 },
> > + .row_depth = { 16 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_YVYU,
> > + .mdp_color = MDP_COLOR_YVYU,
> > + .depth = { 16 },
> > + .row_depth = { 16 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_YUV420,
> > + .mdp_color = MDP_COLOR_I420,
> > + .depth = { 12 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_YVU420,
> > + .mdp_color = MDP_COLOR_YV12,
> > + .depth = { 12 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV12,
> > + .mdp_color = MDP_COLOR_NV12,
> > + .depth = { 12 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV21,
> > + .mdp_color = MDP_COLOR_NV21,
> > + .depth = { 12 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV16,
> > + .mdp_color = MDP_COLOR_NV16,
> > + .depth = { 16 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV61,
> > + .mdp_color = MDP_COLOR_NV61,
> > + .depth = { 16 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV24,
> > + .mdp_color = MDP_COLOR_NV24,
> > + .depth = { 24 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV42,
> > + .mdp_color = MDP_COLOR_NV42,
> > + .depth = { 24 },
> > + .row_depth = { 8 },
> > + .num_planes = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_MT21C,
> > + .mdp_color = MDP_COLOR_420_BLK_UFO,
> > + .depth = { 8, 4 },
> > + .row_depth = { 8, 8 },
> > + .num_planes = 2,
> > + .walign = 4,
> > + .halign = 5,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_MM21,
> > + .mdp_color = MDP_COLOR_420_BLK,
> > + .depth = { 8, 4 },
> > + .row_depth = { 8, 8 },
> > + .num_planes = 2,
> > + .walign = 4,
> > + .halign = 5,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV12M,
> > + .mdp_color = MDP_COLOR_NV12,
> > + .depth = { 8, 4 },
> > + .row_depth = { 8, 8 },
> > + .num_planes = 2,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV21M,
> > + .mdp_color = MDP_COLOR_NV21,
> > + .depth = { 8, 4 },
> > + .row_depth = { 8, 8 },
> > + .num_planes = 2,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV16M,
> > + .mdp_color = MDP_COLOR_NV16,
> > + .depth = { 8, 8 },
> > + .row_depth = { 8, 8 },
> > + .num_planes = 2,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_NV61M,
> > + .mdp_color = MDP_COLOR_NV61,
> > + .depth = { 8, 8 },
> > + .row_depth = { 8, 8 },
> > + .num_planes = 2,
> > + .walign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_YUV420M,
> > + .mdp_color = MDP_COLOR_I420,
> > + .depth = { 8, 2, 2 },
> > + .row_depth = { 8, 4, 4 },
> > + .num_planes = 3,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }, {
> > + .pixelformat = V4L2_PIX_FMT_YVU420M,
> > + .mdp_color = MDP_COLOR_YV12,
> > + .depth = { 8, 2, 2 },
> > + .row_depth = { 8, 4, 4 },
> > + .num_planes = 3,
> > + .walign = 1,
> > + .halign = 1,
> > + .flags = MDP_FMT_FLAG_OUTPUT | MDP_FMT_FLAG_CAPTURE,
> > + }
> > +};
> > +
> > +static const struct mdp_limit mdp_def_limit = {
> > + .out_limit = {
> > + .wmin = 16,
> > + .hmin = 16,
> > + .wmax = 8176,
> > + .hmax = 8176,
> > + },
> > + .cap_limit = {
> > + .wmin = 2,
> > + .hmin = 2,
> > + .wmax = 8176,
> > + .hmax = 8176,
> > + },
> > + .h_scale_up_max = 32,
> > + .v_scale_up_max = 32,
> > + .h_scale_down_max = 20,
> > + .v_scale_down_max = 128,
> > +};
> > +
> > +static const struct mdp_format *mdp_find_fmt(u32 pixelformat, u32 type)
> > +{
> > + u32 i, flag;
> > +
> > + flag = V4L2_TYPE_IS_OUTPUT(type) ? MDP_FMT_FLAG_OUTPUT :
> > + MDP_FMT_FLAG_CAPTURE;
> > + for (i = 0; i < ARRAY_SIZE(mdp_formats); ++i) {
> > + if (!(mdp_formats[i].flags & flag))
> > + continue;
> > + if (mdp_formats[i].pixelformat == pixelformat)
> > + return &mdp_formats[i];
> > + }
> > + return NULL;
> > +}
> > +
> > +static const struct mdp_format *mdp_find_fmt_by_index(u32 index, u32 type)
> > +{
> > + u32 i, flag, num = 0;
> > +
> > + flag = V4L2_TYPE_IS_OUTPUT(type) ? MDP_FMT_FLAG_OUTPUT :
> > + MDP_FMT_FLAG_CAPTURE;
> > + for (i = 0; i < ARRAY_SIZE(mdp_formats); ++i) {
> > + if (!(mdp_formats[i].flags & flag))
> > + continue;
> > + if (index == num)
> > + return &mdp_formats[i];
> > + num++;
> > + }
> > + return NULL;
> > +}
> > +
> > +enum mdp_ycbcr_profile mdp_map_ycbcr_prof_mplane(struct v4l2_format *f,
> > + u32 mdp_color)
> > +{
> > + struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
> > +
> > + 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;
> > + default:
> > + if (pix_mp->quantization == V4L2_QUANTIZATION_FULL_RANGE)
> > + return MDP_YCBCR_PROFILE_FULL_BT601;
> > + return MDP_YCBCR_PROFILE_BT601;
> > + }
> > +}
> > +
> > +static void mdp_bound_align_image(u32 *w, u32 *h,
> > + struct v4l2_frmsize_stepwise *s,
> > + unsigned int salign)
> > +{
> > + unsigned int org_w, org_h;
> > +
> > + org_w = *w;
> > + org_h = *h;
> > + v4l_bound_align_image(w, s->min_width, s->max_width, s->step_width,
> > + h, s->min_height, s->max_height, s->step_height,
> > + salign);
> > +
> > + s->min_width = org_w;
> > + s->min_height = org_h;
> > + v4l2_apply_frmsize_constraints(w, h, s);
> > +}
> > +
> > +static int mdp_clamp_align(s32 *x, int min, int max, unsigned int align)
> > +{
> > + unsigned int mask;
> > +
> > + if (min < 0 || max < 0)
> > + return -ERANGE;
> > +
> > + /* Bits that must be zero to be aligned */
> > + mask = ~((1 << align) - 1);
> > +
> > + min = 0 ? 0 : ((min + ~mask) & mask);
> > + max = max & mask;
> > + if ((unsigned int)min > (unsigned int)max)
> > + return -ERANGE;
> > +
> > + /* Clamp to aligned min and max */
> > + *x = clamp(*x, min, max);
> > +
> > + /* Round to nearest aligned value */
> > + if (align)
> > + *x = (*x + (1 << (align - 1))) & mask;
> > + return 0;
> > +}
> > +
> > +int mdp_enum_fmt_mplane(struct v4l2_fmtdesc *f)
> > +{
> > + const struct mdp_format *fmt;
> > +
> > + fmt = mdp_find_fmt_by_index(f->index, f->type);
> > + if (!fmt)
> > + return -EINVAL;
> > +
> > + f->pixelformat = fmt->pixelformat;
> > + return 0;
> > +}
> > +
> > +const struct mdp_format *mdp_try_fmt_mplane(struct v4l2_format *f,
> > + struct mdp_frameparam *param,
> > + u32 ctx_id)
> > +{
> > + struct device *dev = ¶m->ctx->mdp_dev->pdev->dev;
> > + struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
> > + const struct mdp_format *fmt;
> > + const struct mdp_pix_limit *pix_limit;
> > + struct v4l2_frmsize_stepwise s;
> > + u32 org_w, org_h;
> > + unsigned int i;
> > +
> > + fmt = mdp_find_fmt(pix_mp->pixelformat, f->type);
> > + if (!fmt) {
> > + fmt = mdp_find_fmt_by_index(0, f->type);
> > + if (!fmt) {
> > + dev_dbg(dev, "%d: pixelformat %c%c%c%c invalid", ctx_id,
> > + (pix_mp->pixelformat & 0xff),
> > + (pix_mp->pixelformat >> 8) & 0xff,
> > + (pix_mp->pixelformat >> 16) & 0xff,
> > + (pix_mp->pixelformat >> 24) & 0xff);
> > + return NULL;
> > + }
> > + }
> > +
> > + pix_mp->field = V4L2_FIELD_NONE;
> > + pix_mp->flags = 0;
> > + pix_mp->pixelformat = fmt->pixelformat;
> > + if (!V4L2_TYPE_IS_OUTPUT(f->type)) {
> > + pix_mp->colorspace = param->colorspace;
> > + pix_mp->xfer_func = param->xfer_func;
> > + pix_mp->ycbcr_enc = param->ycbcr_enc;
> > + pix_mp->quantization = param->quant;
> > + }
> > +
> > + pix_limit = V4L2_TYPE_IS_OUTPUT(f->type) ? ¶m->limit->out_limit :
> > + ¶m->limit->cap_limit;
> > + s.min_width = pix_limit->wmin;
> > + s.max_width = pix_limit->wmax;
> > + s.step_width = fmt->walign;
> > + s.min_height = pix_limit->hmin;
> > + s.max_height = pix_limit->hmax;
> > + s.step_height = fmt->halign;
> > + org_w = pix_mp->width;
> > + org_h = pix_mp->height;
> > +
> > + mdp_bound_align_image(&pix_mp->width, &pix_mp->height, &s, fmt->salign);
> > + if (org_w != pix_mp->width || org_h != pix_mp->height)
> > + dev_dbg(dev, "%d: size change: %ux%u to %ux%u", ctx_id,
> > + org_w, org_h, pix_mp->width, pix_mp->height);
> > +
> > + if (pix_mp->num_planes && pix_mp->num_planes != fmt->num_planes)
> > + dev_dbg(dev, "%d num of planes change: %u to %u", ctx_id,
> > + pix_mp->num_planes, fmt->num_planes);
> > + pix_mp->num_planes = fmt->num_planes;
> > +
> > + for (i = 0; i < pix_mp->num_planes; ++i) {
> > + u32 min_bpl = (pix_mp->width * fmt->row_depth[i]) >> 3;
> > + u32 max_bpl = (pix_limit->wmax * fmt->row_depth[i]) >> 3;
> > + u32 bpl = pix_mp->plane_fmt[i].bytesperline;
> > + u32 min_si, max_si;
> > + u32 si = pix_mp->plane_fmt[i].sizeimage;
> > +
> > + bpl = clamp(bpl, min_bpl, max_bpl);
> > + pix_mp->plane_fmt[i].bytesperline = bpl;
> > +
> > + min_si = (bpl * pix_mp->height * fmt->depth[i]) / fmt->row_depth[i];
> > + max_si = (bpl * s.max_height * fmt->depth[i]) / fmt->row_depth[i];
> > +
> > + si = clamp(si, min_si, max_si);
> > + pix_mp->plane_fmt[i].sizeimage = si;
> > +
> > + dev_dbg(dev, "%d: p%u, bpl:%u [%u, %u], sizeimage:%u [%u, %u]", ctx_id,
> > + i, bpl, min_bpl, max_bpl, si, min_si, max_si);
> > + }
> > +
> > + return fmt;
> > +}
> > +
> > +static int mdp_clamp_start(s32 *x, int min, int max, unsigned int align,
> > + u32 flags)
> > +{
> > + if (flags & V4L2_SEL_FLAG_GE)
> > + max = *x;
> > + if (flags & V4L2_SEL_FLAG_LE)
> > + min = *x;
> > + return mdp_clamp_align(x, min, max, align);
> > +}
> > +
> > +static int mdp_clamp_end(s32 *x, int min, int max, unsigned int align,
> > + u32 flags)
> > +{
> > + if (flags & V4L2_SEL_FLAG_GE)
> > + min = *x;
> > + if (flags & V4L2_SEL_FLAG_LE)
> > + max = *x;
> > + return mdp_clamp_align(x, min, max, align);
> > +}
> > +
> > +int mdp_try_crop(struct mdp_m2m_ctx *ctx, struct v4l2_rect *r,
> > + const struct v4l2_selection *s, struct mdp_frame *frame)
> > +{
> > + struct device *dev = &ctx->mdp_dev->pdev->dev;
> > + s32 left, top, right, bottom;
> > + u32 framew, frameh, walign, halign;
> > + int ret;
> > +
> > + dev_dbg(dev, "%d target:%d, set:(%d,%d) %ux%u", ctx->id,
> > + s->target, s->r.left, s->r.top, s->r.width, s->r.height);
> > +
> > + left = s->r.left;
> > + top = s->r.top;
> > + right = s->r.left + s->r.width;
> > + bottom = s->r.top + s->r.height;
> > + framew = frame->format.fmt.pix_mp.width;
> > + frameh = frame->format.fmt.pix_mp.height;
> > +
> > + if (mdp_target_is_crop(s->target)) {
> > + walign = 1;
> > + halign = 1;
> > + } else {
> > + walign = frame->mdp_fmt->walign;
> > + halign = frame->mdp_fmt->halign;
> > + }
> > +
> > + dev_dbg(dev, "%d align:%u,%u, bound:%ux%u", ctx->id,
> > + walign, halign, framew, frameh);
> > +
> > + ret = mdp_clamp_start(&left, 0, right, walign, s->flags);
> > + if (ret)
> > + return ret;
> > + ret = mdp_clamp_start(&top, 0, bottom, halign, s->flags);
> > + if (ret)
> > + return ret;
> > + ret = mdp_clamp_end(&right, left, framew, walign, s->flags);
> > + if (ret)
> > + return ret;
> > + ret = mdp_clamp_end(&bottom, top, frameh, halign, s->flags);
> > + if (ret)
> > + return ret;
> > +
> > + r->left = left;
> > + r->top = top;
> > + r->width = right - left;
> > + r->height = bottom - top;
> > +
> > + dev_dbg(dev, "%d crop:(%d,%d) %ux%u", ctx->id,
> > + r->left, r->top, r->width, r->height);
> > + return 0;
> > +}
> > +
> > +int mdp_check_scaling_ratio(const struct v4l2_rect *crop,
> > + const struct v4l2_rect *compose, s32 rotation,
> > + const struct mdp_limit *limit)
> > +{
> > + u32 crop_w, crop_h, comp_w, comp_h;
> > +
> > + crop_w = crop->width;
> > + crop_h = crop->height;
> > + if (90 == rotation || 270 == rotation) {
> > + comp_w = compose->height;
> > + comp_h = compose->width;
> > + } else {
> > + comp_w = compose->width;
> > + comp_h = compose->height;
> > + }
> > +
> > + if ((crop_w / comp_w) > limit->h_scale_down_max ||
> > + (crop_h / comp_h) > limit->v_scale_down_max ||
> > + (comp_w / crop_w) > limit->h_scale_up_max ||
> > + (comp_h / crop_h) > limit->v_scale_up_max)
> > + return -ERANGE;
> > + return 0;
> > +}
> > +
> > +/* Stride that is accepted by MDP HW */
> > +static u32 mdp_fmt_get_stride(const struct 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 mdp_fmt_get_stride_contig(const struct 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 mdp_fmt_get_plane_size(const struct 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 void mdp_prepare_buffer(struct img_image_buffer *b,
> > + struct mdp_frame *frame, struct vb2_buffer *vb)
> > +{
> > + struct v4l2_pix_format_mplane *pix_mp = &frame->format.fmt.pix_mp;
> > + unsigned int i;
> > +
> > + b->format.colorformat = frame->mdp_fmt->mdp_color;
> > + b->format.ycbcr_prof = frame->ycbcr_prof;
> > + for (i = 0; i < pix_mp->num_planes; ++i) {
> > + u32 stride = mdp_fmt_get_stride(frame->mdp_fmt,
> > + pix_mp->plane_fmt[i].bytesperline, i);
> > +
> > + b->format.plane_fmt[i].stride = stride;
> > + /*
> > + * TODO : The way to pass an offset within a DMA-buf
> > + * is not defined in V4L2 specification, so we abuse
> > + * data_offset for now. Fix it when we have the right interface,
> > + * including any necessary validation and potential alignment
> > + * issues.
> > + */
> > + b->format.plane_fmt[i].size =
> > + mdp_fmt_get_plane_size(frame->mdp_fmt, stride,
> > + pix_mp->height, i) -
> > + vb->planes[i].data_offset;
> > + b->iova[i] = vb2_dma_contig_plane_dma_addr(vb, i) +
> > + vb->planes[i].data_offset;
>
> Why do you need data_offset? What is the use case? Obviously I can't
> merge a driver that abuses an API.
>
> > + }
> > + for (; i < MDP_COLOR_GET_PLANE_COUNT(b->format.colorformat); ++i) {
> > + u32 stride = mdp_fmt_get_stride_contig(frame->mdp_fmt,
> > + b->format.plane_fmt[0].stride, i);
> > +
> > + b->format.plane_fmt[i].stride = stride;
> > + b->format.plane_fmt[i].size =
> > + mdp_fmt_get_plane_size(frame->mdp_fmt, stride,
> > + pix_mp->height, i);
> > + b->iova[i] = b->iova[i - 1] + b->format.plane_fmt[i - 1].size;
> > + }
> > + b->usage = frame->usage;
> > +}
> > +
> > +void mdp_set_src_config(struct img_input *in,
> > + struct mdp_frame *frame, struct vb2_buffer *vb)
> > +{
> > + in->buffer.format.width = frame->format.fmt.pix_mp.width;
> > + in->buffer.format.height = frame->format.fmt.pix_mp.height;
> > + mdp_prepare_buffer(&in->buffer, frame, vb);
> > +}
> > +
> > +static u32 mdp_to_fixed(u32 *r, struct v4l2_fract *f)
> > +{
> > + u32 q;
> > +
> > + if (f->denominator == 0) {
> > + *r = 0;
> > + return 0;
> > + }
> > +
> > + q = f->numerator / f->denominator;
> > + *r = div_u64(((u64)f->numerator - q * f->denominator) <<
> > + IMG_SUBPIXEL_SHIFT, f->denominator);
> > + return q;
> > +}
> > +
> > +static void mdp_set_src_crop(struct img_crop *c, struct mdp_crop *crop)
> > +{
> > + c->left = crop->c.left
> > + + mdp_to_fixed(&c->left_subpix, &crop->left_subpix);
> > + c->top = crop->c.top
> > + + mdp_to_fixed(&c->top_subpix, &crop->top_subpix);
> > + c->width = crop->c.width
> > + + mdp_to_fixed(&c->width_subpix, &crop->width_subpix);
> > + c->height = crop->c.height
> > + + mdp_to_fixed(&c->height_subpix, &crop->height_subpix);
> > +}
> > +
> > +static void mdp_set_orientation(struct img_output *out,
> > + s32 rotation, bool hflip, bool vflip)
> > +{
> > + u8 flip = 0;
> > +
> > + if (hflip)
> > + flip ^= 1;
> > + if (vflip) {
> > + /*
> > + * A vertical flip is equivalent to
> > + * a 180-degree rotation with a horizontal flip
> > + */
> > + rotation += 180;
> > + flip ^= 1;
> > + }
> > +
> > + out->rotation = rotation % 360;
> > + if (flip != 0)
> > + out->flags |= IMG_CTRL_FLAG_HFLIP;
> > + else
> > + out->flags &= ~IMG_CTRL_FLAG_HFLIP;
> > +}
> > +
> > +void mdp_set_dst_config(struct img_output *out,
> > + struct mdp_frame *frame, struct vb2_buffer *vb)
> > +{
> > + out->buffer.format.width = frame->compose.width;
> > + out->buffer.format.height = frame->compose.height;
> > + mdp_prepare_buffer(&out->buffer, frame, vb);
> > + mdp_set_src_crop(&out->crop, &frame->crop);
> > + mdp_set_orientation(out, frame->rotation, frame->hflip, frame->vflip);
> > +}
> > +
> > +int mdp_frameparam_init(struct mdp_frameparam *param)
> > +{
> > + struct mdp_frame *frame;
> > +
> > + if (!param)
> > + return -EINVAL;
> > +
> > + INIT_LIST_HEAD(¶m->list);
> > + param->limit = &mdp_def_limit;
> > + param->type = MDP_STREAM_TYPE_BITBLT;
> > +
> > + frame = ¶m->output;
> > + frame->format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
> > + frame->mdp_fmt = mdp_try_fmt_mplane(&frame->format, param, 0);
> > + frame->ycbcr_prof =
> > + mdp_map_ycbcr_prof_mplane(&frame->format,
> > + frame->mdp_fmt->mdp_color);
> > + frame->usage = MDP_BUFFER_USAGE_HW_READ;
> > +
> > + param->num_captures = 1;
> > + frame = ¶m->captures[0];
> > + frame->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> > + frame->mdp_fmt = mdp_try_fmt_mplane(&frame->format, param, 0);
> > + frame->ycbcr_prof =
> > + mdp_map_ycbcr_prof_mplane(&frame->format,
> > + frame->mdp_fmt->mdp_color);
> > + frame->usage = MDP_BUFFER_USAGE_MDP;
> > + frame->crop.c.width = param->output.format.fmt.pix_mp.width;
> > + frame->crop.c.height = param->output.format.fmt.pix_mp.height;
> > + frame->compose.width = frame->format.fmt.pix_mp.width;
> > + frame->compose.height = frame->format.fmt.pix_mp.height;
> > +
> > + return 0;
> > +}
--
Regards,
Laurent Pinchart
More information about the linux-arm-kernel
mailing list