From 8bbc139c6bde391d00835dd74e2326f50045cde4 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Sun, 13 Mar 2022 11:18:13 +0100 Subject: media: platform: rename mtk-jpeg/ to mediatek/mtk-jpeg/ As the end goal is to have platform drivers split by vendor, rename mtk-jpeg/ to mediatek/mtk-jpeg/. Signed-off-by: Mauro Carvalho Chehab --- drivers/media/platform/Kconfig | 2 +- drivers/media/platform/Makefile | 2 +- drivers/media/platform/mediatek/mtk-jpeg/Kconfig | 16 + drivers/media/platform/mediatek/mtk-jpeg/Makefile | 6 + .../platform/mediatek/mtk-jpeg/mtk_jpeg_core.c | 1528 ++++++++++++++++++++ .../platform/mediatek/mtk-jpeg/mtk_jpeg_core.h | 163 +++ .../platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.c | 409 ++++++ .../platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.h | 79 + .../mediatek/mtk-jpeg/mtk_jpeg_dec_parse.c | 152 ++ .../mediatek/mtk-jpeg/mtk_jpeg_dec_parse.h | 17 + .../platform/mediatek/mtk-jpeg/mtk_jpeg_dec_reg.h | 49 + .../platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.c | 154 ++ .../platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.h | 91 ++ drivers/media/platform/mtk-jpeg/Kconfig | 16 - drivers/media/platform/mtk-jpeg/Makefile | 6 - drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c | 1528 -------------------- drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h | 163 --- drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.c | 409 ------ drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h | 79 - .../media/platform/mtk-jpeg/mtk_jpeg_dec_parse.c | 152 -- .../media/platform/mtk-jpeg/mtk_jpeg_dec_parse.h | 17 - drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_reg.h | 49 - drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c | 154 -- drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h | 91 -- 24 files changed, 2666 insertions(+), 2666 deletions(-) create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/Kconfig create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/Makefile create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.c create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.h create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.c create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.h create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.c create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.h create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_reg.h create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.c create mode 100644 drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.h delete mode 100644 drivers/media/platform/mtk-jpeg/Kconfig delete mode 100644 drivers/media/platform/mtk-jpeg/Makefile delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.c delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.c delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.h delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_reg.h delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c delete mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h (limited to 'drivers/media/platform') diff --git a/drivers/media/platform/Kconfig b/drivers/media/platform/Kconfig index b4faee0a1b63..f1746529e763 100644 --- a/drivers/media/platform/Kconfig +++ b/drivers/media/platform/Kconfig @@ -78,7 +78,7 @@ source "drivers/media/platform/exynos-gsc/Kconfig" source "drivers/media/platform/exynos4-is/Kconfig" source "drivers/media/platform/intel/Kconfig" source "drivers/media/platform/marvell/Kconfig" -source "drivers/media/platform/mtk-jpeg/Kconfig" +source "drivers/media/platform/mediatek/mtk-jpeg/Kconfig" source "drivers/media/platform/mtk-mdp/Kconfig" source "drivers/media/platform/mtk-vcodec/Kconfig" source "drivers/media/platform/mtk-vpu/Kconfig" diff --git a/drivers/media/platform/Makefile b/drivers/media/platform/Makefile index 48531f93d92f..c792f6216918 100644 --- a/drivers/media/platform/Makefile +++ b/drivers/media/platform/Makefile @@ -18,7 +18,7 @@ obj-y += exynos-gsc/ obj-y += exynos4-is/ obj-y += intel/ obj-y += marvell/ -obj-y += mtk-jpeg/ +obj-y += mediatek/mtk-jpeg/ obj-y += mtk-mdp/ obj-y += mtk-vcodec/ obj-y += mtk-vpu/ diff --git a/drivers/media/platform/mediatek/mtk-jpeg/Kconfig b/drivers/media/platform/mediatek/mtk-jpeg/Kconfig new file mode 100644 index 000000000000..72ed920b011a --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/Kconfig @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: GPL-2.0-only +config VIDEO_MEDIATEK_JPEG + tristate "Mediatek JPEG Codec driver" + depends on V4L_MEM2MEM_DRIVERS + depends on MTK_IOMMU_V1 || MTK_IOMMU || COMPILE_TEST + depends on VIDEO_DEV && VIDEO_V4L2 + depends on ARCH_MEDIATEK || COMPILE_TEST + depends on MTK_SMI || (COMPILE_TEST && MTK_SMI=n) + select VIDEOBUF2_DMA_CONTIG + select V4L2_MEM2MEM_DEV + help + Mediatek jpeg codec driver provides HW capability to decode + JPEG format + + To compile this driver as a module, choose M here: the + module will be called mtk-jpeg diff --git a/drivers/media/platform/mediatek/mtk-jpeg/Makefile b/drivers/media/platform/mediatek/mtk-jpeg/Makefile new file mode 100644 index 000000000000..76c33aad0f3f --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/Makefile @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0-only +mtk_jpeg-objs := mtk_jpeg_core.o \ + mtk_jpeg_dec_hw.o \ + mtk_jpeg_dec_parse.o \ + mtk_jpeg_enc_hw.o +obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk_jpeg.o diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.c new file mode 100644 index 000000000000..ab5485dfc20c --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.c @@ -0,0 +1,1528 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + * Xia Jiang + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mtk_jpeg_enc_hw.h" +#include "mtk_jpeg_dec_hw.h" +#include "mtk_jpeg_core.h" +#include "mtk_jpeg_dec_parse.h" + +static struct mtk_jpeg_fmt mtk_jpeg_enc_formats[] = { + { + .fourcc = V4L2_PIX_FMT_JPEG, + .colplanes = 1, + .flags = MTK_JPEG_FMT_FLAG_CAPTURE, + }, + { + .fourcc = V4L2_PIX_FMT_NV12M, + .hw_format = JPEG_ENC_YUV_FORMAT_NV12, + .h_sample = {4, 4}, + .v_sample = {4, 2}, + .colplanes = 2, + .h_align = 4, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_NV21M, + .hw_format = JEPG_ENC_YUV_FORMAT_NV21, + .h_sample = {4, 4}, + .v_sample = {4, 2}, + .colplanes = 2, + .h_align = 4, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YUYV, + .hw_format = JPEG_ENC_YUV_FORMAT_YUYV, + .h_sample = {8}, + .v_sample = {4}, + .colplanes = 1, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YVYU, + .hw_format = JPEG_ENC_YUV_FORMAT_YVYU, + .h_sample = {8}, + .v_sample = {4}, + .colplanes = 1, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, +}; + +static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { + { + .fourcc = V4L2_PIX_FMT_JPEG, + .colplanes = 1, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YUV420M, + .h_sample = {4, 2, 2}, + .v_sample = {4, 2, 2}, + .colplanes = 3, + .h_align = 5, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_CAPTURE, + }, + { + .fourcc = V4L2_PIX_FMT_YUV422M, + .h_sample = {4, 2, 2}, + .v_sample = {4, 4, 4}, + .colplanes = 3, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_CAPTURE, + }, +}; + +#define MTK_JPEG_ENC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_enc_formats) +#define MTK_JPEG_DEC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_dec_formats) + +struct mtk_jpeg_src_buf { + struct vb2_v4l2_buffer b; + struct list_head list; + struct mtk_jpeg_dec_param dec_param; +}; + +static int debug; +module_param(debug, int, 0644); + +static inline struct mtk_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl) +{ + return container_of(ctrl->handler, struct mtk_jpeg_ctx, ctrl_hdl); +} + +static inline struct mtk_jpeg_ctx *mtk_jpeg_fh_to_ctx(struct v4l2_fh *fh) +{ + return container_of(fh, struct mtk_jpeg_ctx, fh); +} + +static inline struct mtk_jpeg_src_buf *mtk_jpeg_vb2_to_srcbuf( + struct vb2_buffer *vb) +{ + return container_of(to_vb2_v4l2_buffer(vb), struct mtk_jpeg_src_buf, b); +} + +static int mtk_jpeg_querycap(struct file *file, void *priv, + struct v4l2_capability *cap) +{ + struct mtk_jpeg_dev *jpeg = video_drvdata(file); + + strscpy(cap->driver, jpeg->variant->dev_name, sizeof(cap->driver)); + strscpy(cap->card, jpeg->variant->dev_name, sizeof(cap->card)); + snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", + dev_name(jpeg->dev)); + + return 0; +} + +static int vidioc_jpeg_enc_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct mtk_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); + + switch (ctrl->id) { + case V4L2_CID_JPEG_RESTART_INTERVAL: + ctx->restart_interval = ctrl->val; + break; + case V4L2_CID_JPEG_COMPRESSION_QUALITY: + ctx->enc_quality = ctrl->val; + break; + case V4L2_CID_JPEG_ACTIVE_MARKER: + ctx->enable_exif = ctrl->val & V4L2_JPEG_ACTIVE_MARKER_APP1; + break; + } + + return 0; +} + +static const struct v4l2_ctrl_ops mtk_jpeg_enc_ctrl_ops = { + .s_ctrl = vidioc_jpeg_enc_s_ctrl, +}; + +static int mtk_jpeg_enc_ctrls_setup(struct mtk_jpeg_ctx *ctx) +{ + const struct v4l2_ctrl_ops *ops = &mtk_jpeg_enc_ctrl_ops; + struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl; + + v4l2_ctrl_handler_init(handler, 3); + + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, + 1, 0); + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_COMPRESSION_QUALITY, 48, + 100, 1, 90); + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_ACTIVE_MARKER, 0, + V4L2_JPEG_ACTIVE_MARKER_APP1, 0, 0); + + if (handler->error) { + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); + return handler->error; + } + + v4l2_ctrl_handler_setup(&ctx->ctrl_hdl); + + return 0; +} + +static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, + struct v4l2_fmtdesc *f, u32 type) +{ + int i, num = 0; + + for (i = 0; i < n; ++i) { + if (mtk_jpeg_formats[i].flags & type) { + if (num == f->index) + break; + ++num; + } + } + + if (i >= n) + return -EINVAL; + + f->pixelformat = mtk_jpeg_formats[i].fourcc; + + return 0; +} + +static int mtk_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, + struct v4l2_fmtdesc *f) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + return mtk_jpeg_enum_fmt(jpeg->variant->formats, + jpeg->variant->num_formats, f, + MTK_JPEG_FMT_FLAG_CAPTURE); +} + +static int mtk_jpeg_enum_fmt_vid_out(struct file *file, void *priv, + struct v4l2_fmtdesc *f) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + return mtk_jpeg_enum_fmt(jpeg->variant->formats, + jpeg->variant->num_formats, f, + MTK_JPEG_FMT_FLAG_OUTPUT); +} + +static struct mtk_jpeg_q_data *mtk_jpeg_get_q_data(struct mtk_jpeg_ctx *ctx, + enum v4l2_buf_type type) +{ + if (V4L2_TYPE_IS_OUTPUT(type)) + return &ctx->out_q; + return &ctx->cap_q; +} + +static struct mtk_jpeg_fmt * +mtk_jpeg_find_format(struct mtk_jpeg_fmt *mtk_jpeg_formats, int num_formats, + u32 pixelformat, unsigned int fmt_type) +{ + unsigned int k; + struct mtk_jpeg_fmt *fmt; + + for (k = 0; k < num_formats; k++) { + fmt = &mtk_jpeg_formats[k]; + + if (fmt->fourcc == pixelformat && fmt->flags & fmt_type) + return fmt; + } + + return NULL; +} + +static int mtk_jpeg_try_fmt_mplane(struct v4l2_pix_format_mplane *pix_mp, + struct mtk_jpeg_fmt *fmt) +{ + int i; + + pix_mp->field = V4L2_FIELD_NONE; + + pix_mp->num_planes = fmt->colplanes; + pix_mp->pixelformat = fmt->fourcc; + + if (fmt->fourcc == V4L2_PIX_FMT_JPEG) { + struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[0]; + + pix_mp->height = clamp(pix_mp->height, MTK_JPEG_MIN_HEIGHT, + MTK_JPEG_MAX_HEIGHT); + pix_mp->width = clamp(pix_mp->width, MTK_JPEG_MIN_WIDTH, + MTK_JPEG_MAX_WIDTH); + + pfmt->bytesperline = 0; + /* Source size must be aligned to 128 */ + pfmt->sizeimage = round_up(pfmt->sizeimage, 128); + if (pfmt->sizeimage == 0) + pfmt->sizeimage = MTK_JPEG_DEFAULT_SIZEIMAGE; + return 0; + } + + /* other fourcc */ + pix_mp->height = clamp(round_up(pix_mp->height, fmt->v_align), + MTK_JPEG_MIN_HEIGHT, MTK_JPEG_MAX_HEIGHT); + pix_mp->width = clamp(round_up(pix_mp->width, fmt->h_align), + MTK_JPEG_MIN_WIDTH, MTK_JPEG_MAX_WIDTH); + + for (i = 0; i < fmt->colplanes; i++) { + struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[i]; + u32 stride = pix_mp->width * fmt->h_sample[i] / 4; + u32 h = pix_mp->height * fmt->v_sample[i] / 4; + + pfmt->bytesperline = stride; + pfmt->sizeimage = stride * h; + } + return 0; +} + +static int mtk_jpeg_g_fmt_vid_mplane(struct file *file, void *priv, + struct v4l2_format *f) +{ + struct vb2_queue *vq; + struct mtk_jpeg_q_data *q_data = NULL; + struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + int i; + + vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); + if (!vq) + return -EINVAL; + + q_data = mtk_jpeg_get_q_data(ctx, f->type); + + pix_mp->width = q_data->pix_mp.width; + pix_mp->height = q_data->pix_mp.height; + pix_mp->field = V4L2_FIELD_NONE; + pix_mp->pixelformat = q_data->fmt->fourcc; + pix_mp->num_planes = q_data->fmt->colplanes; + pix_mp->colorspace = q_data->pix_mp.colorspace; + pix_mp->ycbcr_enc = q_data->pix_mp.ycbcr_enc; + pix_mp->xfer_func = q_data->pix_mp.xfer_func; + pix_mp->quantization = q_data->pix_mp.quantization; + + v4l2_dbg(1, debug, &jpeg->v4l2_dev, "(%d) g_fmt:%c%c%c%c wxh:%ux%u\n", + f->type, + (pix_mp->pixelformat & 0xff), + (pix_mp->pixelformat >> 8 & 0xff), + (pix_mp->pixelformat >> 16 & 0xff), + (pix_mp->pixelformat >> 24 & 0xff), + pix_mp->width, pix_mp->height); + + for (i = 0; i < pix_mp->num_planes; i++) { + struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[i]; + + pfmt->bytesperline = q_data->pix_mp.plane_fmt[i].bytesperline; + pfmt->sizeimage = q_data->pix_mp.plane_fmt[i].sizeimage; + + v4l2_dbg(1, debug, &jpeg->v4l2_dev, + "plane[%d] bpl=%u, size=%u\n", + i, + pfmt->bytesperline, + pfmt->sizeimage); + } + return 0; +} + +static int mtk_jpeg_try_fmt_vid_cap_mplane(struct file *file, void *priv, + struct v4l2_format *f) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct mtk_jpeg_fmt *fmt; + + fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + f->fmt.pix_mp.pixelformat, + MTK_JPEG_FMT_FLAG_CAPTURE); + if (!fmt) + fmt = ctx->cap_q.fmt; + + v4l2_dbg(2, debug, &ctx->jpeg->v4l2_dev, "(%d) try_fmt:%c%c%c%c\n", + f->type, + (fmt->fourcc & 0xff), + (fmt->fourcc >> 8 & 0xff), + (fmt->fourcc >> 16 & 0xff), + (fmt->fourcc >> 24 & 0xff)); + + if (ctx->state != MTK_JPEG_INIT) { + mtk_jpeg_g_fmt_vid_mplane(file, priv, f); + return 0; + } + + return mtk_jpeg_try_fmt_mplane(&f->fmt.pix_mp, fmt); +} + +static int mtk_jpeg_try_fmt_vid_out_mplane(struct file *file, void *priv, + struct v4l2_format *f) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct mtk_jpeg_fmt *fmt; + + fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + f->fmt.pix_mp.pixelformat, + MTK_JPEG_FMT_FLAG_OUTPUT); + if (!fmt) + fmt = ctx->out_q.fmt; + + v4l2_dbg(2, debug, &ctx->jpeg->v4l2_dev, "(%d) try_fmt:%c%c%c%c\n", + f->type, + (fmt->fourcc & 0xff), + (fmt->fourcc >> 8 & 0xff), + (fmt->fourcc >> 16 & 0xff), + (fmt->fourcc >> 24 & 0xff)); + + if (ctx->state != MTK_JPEG_INIT) { + mtk_jpeg_g_fmt_vid_mplane(file, priv, f); + return 0; + } + + return mtk_jpeg_try_fmt_mplane(&f->fmt.pix_mp, fmt); +} + +static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, + struct v4l2_format *f, unsigned int fmt_type) +{ + struct vb2_queue *vq; + struct mtk_jpeg_q_data *q_data = NULL; + struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + int i; + + vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); + if (!vq) + return -EINVAL; + + q_data = mtk_jpeg_get_q_data(ctx, f->type); + + if (vb2_is_busy(vq)) { + v4l2_err(&jpeg->v4l2_dev, "queue busy\n"); + return -EBUSY; + } + + q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + pix_mp->pixelformat, fmt_type); + q_data->pix_mp.width = pix_mp->width; + q_data->pix_mp.height = pix_mp->height; + q_data->enc_crop_rect.width = pix_mp->width; + q_data->enc_crop_rect.height = pix_mp->height; + q_data->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; + q_data->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; + q_data->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; + q_data->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; + + v4l2_dbg(1, debug, &jpeg->v4l2_dev, "(%d) s_fmt:%c%c%c%c wxh:%ux%u\n", + f->type, + (q_data->fmt->fourcc & 0xff), + (q_data->fmt->fourcc >> 8 & 0xff), + (q_data->fmt->fourcc >> 16 & 0xff), + (q_data->fmt->fourcc >> 24 & 0xff), + q_data->pix_mp.width, q_data->pix_mp.height); + + for (i = 0; i < q_data->fmt->colplanes; i++) { + q_data->pix_mp.plane_fmt[i].bytesperline = + pix_mp->plane_fmt[i].bytesperline; + q_data->pix_mp.plane_fmt[i].sizeimage = + pix_mp->plane_fmt[i].sizeimage; + + v4l2_dbg(1, debug, &jpeg->v4l2_dev, + "plane[%d] bpl=%u, size=%u\n", + i, q_data->pix_mp.plane_fmt[i].bytesperline, + q_data->pix_mp.plane_fmt[i].sizeimage); + } + + return 0; +} + +static int mtk_jpeg_s_fmt_vid_out_mplane(struct file *file, void *priv, + struct v4l2_format *f) +{ + int ret; + + ret = mtk_jpeg_try_fmt_vid_out_mplane(file, priv, f); + if (ret) + return ret; + + return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, + MTK_JPEG_FMT_FLAG_OUTPUT); +} + +static int mtk_jpeg_s_fmt_vid_cap_mplane(struct file *file, void *priv, + struct v4l2_format *f) +{ + int ret; + + ret = mtk_jpeg_try_fmt_vid_cap_mplane(file, priv, f); + if (ret) + return ret; + + return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, + MTK_JPEG_FMT_FLAG_CAPTURE); +} + +static void mtk_jpeg_queue_src_chg_event(struct mtk_jpeg_ctx *ctx) +{ + static const struct v4l2_event ev_src_ch = { + .type = V4L2_EVENT_SOURCE_CHANGE, + .u.src_change.changes = + V4L2_EVENT_SRC_CH_RESOLUTION, + }; + + v4l2_event_queue_fh(&ctx->fh, &ev_src_ch); +} + +static int mtk_jpeg_subscribe_event(struct v4l2_fh *fh, + const struct v4l2_event_subscription *sub) +{ + switch (sub->type) { + case V4L2_EVENT_SOURCE_CHANGE: + return v4l2_src_change_event_subscribe(fh, sub); + } + + return v4l2_ctrl_subscribe_event(fh, sub); +} + +static int mtk_jpeg_enc_g_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_CROP: + s->r = ctx->out_q.enc_crop_rect; + break; + case V4L2_SEL_TGT_CROP_BOUNDS: + case V4L2_SEL_TGT_CROP_DEFAULT: + s->r.width = ctx->out_q.pix_mp.width; + s->r.height = ctx->out_q.pix_mp.height; + s->r.left = 0; + s->r.top = 0; + break; + default: + return -EINVAL; + } + return 0; +} + +static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_COMPOSE: + case V4L2_SEL_TGT_COMPOSE_DEFAULT: + s->r.width = ctx->out_q.pix_mp.width; + s->r.height = ctx->out_q.pix_mp.height; + s->r.left = 0; + s->r.top = 0; + break; + case V4L2_SEL_TGT_COMPOSE_BOUNDS: + case V4L2_SEL_TGT_COMPOSE_PADDED: + s->r.width = ctx->cap_q.pix_mp.width; + s->r.height = ctx->cap_q.pix_mp.height; + s->r.left = 0; + s->r.top = 0; + break; + default: + return -EINVAL; + } + return 0; +} + +static int mtk_jpeg_enc_s_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_CROP: + s->r.left = 0; + s->r.top = 0; + s->r.width = min(s->r.width, ctx->out_q.pix_mp.width); + s->r.height = min(s->r.height, ctx->out_q.pix_mp.height); + ctx->out_q.enc_crop_rect = s->r; + break; + default: + return -EINVAL; + } + + return 0; +} + +static const struct v4l2_ioctl_ops mtk_jpeg_enc_ioctl_ops = { + .vidioc_querycap = mtk_jpeg_querycap, + .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, + .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, + .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, + .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, + .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, + .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, + .vidioc_subscribe_event = mtk_jpeg_subscribe_event, + .vidioc_g_selection = mtk_jpeg_enc_g_selection, + .vidioc_s_selection = mtk_jpeg_enc_s_selection, + + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, + .vidioc_streamon = v4l2_m2m_ioctl_streamon, + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, + + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, +}; + +static const struct v4l2_ioctl_ops mtk_jpeg_dec_ioctl_ops = { + .vidioc_querycap = mtk_jpeg_querycap, + .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, + .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, + .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, + .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, + .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, + .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, + .vidioc_subscribe_event = mtk_jpeg_subscribe_event, + .vidioc_g_selection = mtk_jpeg_dec_g_selection, + + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, + .vidioc_streamon = v4l2_m2m_ioctl_streamon, + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, + + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, +}; + +static int mtk_jpeg_queue_setup(struct vb2_queue *q, + unsigned int *num_buffers, + unsigned int *num_planes, + unsigned int sizes[], + struct device *alloc_ctxs[]) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); + struct mtk_jpeg_q_data *q_data = NULL; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + int i; + + v4l2_dbg(1, debug, &jpeg->v4l2_dev, "(%d) buf_req count=%u\n", + q->type, *num_buffers); + + q_data = mtk_jpeg_get_q_data(ctx, q->type); + if (!q_data) + return -EINVAL; + + if (*num_planes) { + for (i = 0; i < *num_planes; i++) + if (sizes[i] < q_data->pix_mp.plane_fmt[i].sizeimage) + return -EINVAL; + return 0; + } + + *num_planes = q_data->fmt->colplanes; + for (i = 0; i < q_data->fmt->colplanes; i++) { + sizes[i] = q_data->pix_mp.plane_fmt[i].sizeimage; + v4l2_dbg(1, debug, &jpeg->v4l2_dev, "sizeimage[%d]=%u\n", + i, sizes[i]); + } + + return 0; +} + +static int mtk_jpeg_buf_prepare(struct vb2_buffer *vb) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct mtk_jpeg_q_data *q_data = NULL; + struct v4l2_plane_pix_format plane_fmt; + int i; + + q_data = mtk_jpeg_get_q_data(ctx, vb->vb2_queue->type); + if (!q_data) + return -EINVAL; + + for (i = 0; i < q_data->fmt->colplanes; i++) { + plane_fmt = q_data->pix_mp.plane_fmt[i]; + if (ctx->enable_exif && + q_data->fmt->fourcc == V4L2_PIX_FMT_JPEG) + vb2_set_plane_payload(vb, i, plane_fmt.sizeimage + + MTK_JPEG_MAX_EXIF_SIZE); + else + vb2_set_plane_payload(vb, i, plane_fmt.sizeimage); + } + + return 0; +} + +static bool mtk_jpeg_check_resolution_change(struct mtk_jpeg_ctx *ctx, + struct mtk_jpeg_dec_param *param) +{ + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct mtk_jpeg_q_data *q_data; + + q_data = &ctx->out_q; + if (q_data->pix_mp.width != param->pic_w || + q_data->pix_mp.height != param->pic_h) { + v4l2_dbg(1, debug, &jpeg->v4l2_dev, "Picture size change\n"); + return true; + } + + q_data = &ctx->cap_q; + if (q_data->fmt != + mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, param->dst_fourcc, + MTK_JPEG_FMT_FLAG_CAPTURE)) { + v4l2_dbg(1, debug, &jpeg->v4l2_dev, "format change\n"); + return true; + } + return false; +} + +static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, + struct mtk_jpeg_dec_param *param) +{ + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct mtk_jpeg_q_data *q_data; + int i; + + q_data = &ctx->out_q; + q_data->pix_mp.width = param->pic_w; + q_data->pix_mp.height = param->pic_h; + + q_data = &ctx->cap_q; + q_data->pix_mp.width = param->dec_w; + q_data->pix_mp.height = param->dec_h; + q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + param->dst_fourcc, + MTK_JPEG_FMT_FLAG_CAPTURE); + + for (i = 0; i < q_data->fmt->colplanes; i++) { + q_data->pix_mp.plane_fmt[i].bytesperline = param->mem_stride[i]; + q_data->pix_mp.plane_fmt[i].sizeimage = param->comp_size[i]; + } + + v4l2_dbg(1, debug, &jpeg->v4l2_dev, + "set_parse cap:%c%c%c%c pic(%u, %u), buf(%u, %u)\n", + (param->dst_fourcc & 0xff), + (param->dst_fourcc >> 8 & 0xff), + (param->dst_fourcc >> 16 & 0xff), + (param->dst_fourcc >> 24 & 0xff), + param->pic_w, param->pic_h, + param->dec_w, param->dec_h); +} + +static void mtk_jpeg_enc_buf_queue(struct vb2_buffer *vb) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", + vb->vb2_queue->type, vb->index, vb); + + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); +} + +static void mtk_jpeg_dec_buf_queue(struct vb2_buffer *vb) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct mtk_jpeg_dec_param *param; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct mtk_jpeg_src_buf *jpeg_src_buf; + bool header_valid; + + v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", + vb->vb2_queue->type, vb->index, vb); + + if (vb->vb2_queue->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) + goto end; + + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(vb); + param = &jpeg_src_buf->dec_param; + memset(param, 0, sizeof(*param)); + + header_valid = mtk_jpeg_parse(param, (u8 *)vb2_plane_vaddr(vb, 0), + vb2_get_plane_payload(vb, 0)); + if (!header_valid) { + v4l2_err(&jpeg->v4l2_dev, "Header invalid.\n"); + vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); + return; + } + + if (ctx->state == MTK_JPEG_INIT) { + struct vb2_queue *dst_vq = v4l2_m2m_get_vq( + ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); + + mtk_jpeg_queue_src_chg_event(ctx); + mtk_jpeg_set_queue_data(ctx, param); + ctx->state = vb2_is_streaming(dst_vq) ? + MTK_JPEG_SOURCE_CHANGE : MTK_JPEG_RUNNING; + } +end: + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); +} + +static struct vb2_v4l2_buffer *mtk_jpeg_buf_remove(struct mtk_jpeg_ctx *ctx, + enum v4l2_buf_type type) +{ + if (V4L2_TYPE_IS_OUTPUT(type)) + return v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + else + return v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); +} + +static void mtk_jpeg_enc_stop_streaming(struct vb2_queue *q) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); + struct vb2_v4l2_buffer *vb; + + while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); +} + +static void mtk_jpeg_dec_stop_streaming(struct vb2_queue *q) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); + struct vb2_v4l2_buffer *vb; + + /* + * STREAMOFF is an acknowledgment for source change event. + * Before STREAMOFF, we still have to return the old resolution and + * subsampling. Update capture queue when the stream is off. + */ + if (ctx->state == MTK_JPEG_SOURCE_CHANGE && + V4L2_TYPE_IS_CAPTURE(q->type)) { + struct mtk_jpeg_src_buf *src_buf; + + vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + src_buf = mtk_jpeg_vb2_to_srcbuf(&vb->vb2_buf); + mtk_jpeg_set_queue_data(ctx, &src_buf->dec_param); + ctx->state = MTK_JPEG_RUNNING; + } else if (V4L2_TYPE_IS_OUTPUT(q->type)) { + ctx->state = MTK_JPEG_INIT; + } + + while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); +} + +static const struct vb2_ops mtk_jpeg_dec_qops = { + .queue_setup = mtk_jpeg_queue_setup, + .buf_prepare = mtk_jpeg_buf_prepare, + .buf_queue = mtk_jpeg_dec_buf_queue, + .wait_prepare = vb2_ops_wait_prepare, + .wait_finish = vb2_ops_wait_finish, + .stop_streaming = mtk_jpeg_dec_stop_streaming, +}; + +static const struct vb2_ops mtk_jpeg_enc_qops = { + .queue_setup = mtk_jpeg_queue_setup, + .buf_prepare = mtk_jpeg_buf_prepare, + .buf_queue = mtk_jpeg_enc_buf_queue, + .wait_prepare = vb2_ops_wait_prepare, + .wait_finish = vb2_ops_wait_finish, + .stop_streaming = mtk_jpeg_enc_stop_streaming, +}; + +static void mtk_jpeg_set_dec_src(struct mtk_jpeg_ctx *ctx, + struct vb2_buffer *src_buf, + struct mtk_jpeg_bs *bs) +{ + bs->str_addr = vb2_dma_contig_plane_dma_addr(src_buf, 0); + bs->end_addr = bs->str_addr + + round_up(vb2_get_plane_payload(src_buf, 0), 16); + bs->size = round_up(vb2_plane_size(src_buf, 0), 128); +} + +static int mtk_jpeg_set_dec_dst(struct mtk_jpeg_ctx *ctx, + struct mtk_jpeg_dec_param *param, + struct vb2_buffer *dst_buf, + struct mtk_jpeg_fb *fb) +{ + int i; + + if (param->comp_num != dst_buf->num_planes) { + dev_err(ctx->jpeg->dev, "plane number mismatch (%u != %u)\n", + param->comp_num, dst_buf->num_planes); + return -EINVAL; + } + + for (i = 0; i < dst_buf->num_planes; i++) { + if (vb2_plane_size(dst_buf, i) < param->comp_size[i]) { + dev_err(ctx->jpeg->dev, + "buffer size is underflow (%lu < %u)\n", + vb2_plane_size(dst_buf, 0), + param->comp_size[i]); + return -EINVAL; + } + fb->plane_addr[i] = vb2_dma_contig_plane_dma_addr(dst_buf, i); + } + + return 0; +} + +static void mtk_jpeg_enc_device_run(void *priv) +{ + struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + unsigned long flags; + int ret; + + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); + + ret = pm_runtime_resume_and_get(jpeg->dev); + if (ret < 0) + goto enc_end; + + schedule_delayed_work(&jpeg->job_timeout_work, + msecs_to_jiffies(MTK_JPEG_HW_TIMEOUT_MSEC)); + + spin_lock_irqsave(&jpeg->hw_lock, flags); + + /* + * Resetting the hardware every frame is to ensure that all the + * registers are cleared. This is a hardware requirement. + */ + mtk_jpeg_enc_reset(jpeg->reg_base); + + mtk_jpeg_set_enc_src(ctx, jpeg->reg_base, &src_buf->vb2_buf); + mtk_jpeg_set_enc_dst(ctx, jpeg->reg_base, &dst_buf->vb2_buf); + mtk_jpeg_set_enc_params(ctx, jpeg->reg_base); + mtk_jpeg_enc_start(jpeg->reg_base); + spin_unlock_irqrestore(&jpeg->hw_lock, flags); + return; + +enc_end: + v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); +} + +static void mtk_jpeg_dec_device_run(void *priv) +{ + struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + unsigned long flags; + struct mtk_jpeg_src_buf *jpeg_src_buf; + struct mtk_jpeg_bs bs; + struct mtk_jpeg_fb fb; + int ret; + + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); + + if (mtk_jpeg_check_resolution_change(ctx, &jpeg_src_buf->dec_param)) { + mtk_jpeg_queue_src_chg_event(ctx); + ctx->state = MTK_JPEG_SOURCE_CHANGE; + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); + return; + } + + ret = pm_runtime_resume_and_get(jpeg->dev); + if (ret < 0) + goto dec_end; + + schedule_delayed_work(&jpeg->job_timeout_work, + msecs_to_jiffies(MTK_JPEG_HW_TIMEOUT_MSEC)); + + mtk_jpeg_set_dec_src(ctx, &src_buf->vb2_buf, &bs); + if (mtk_jpeg_set_dec_dst(ctx, &jpeg_src_buf->dec_param, &dst_buf->vb2_buf, &fb)) + goto dec_end; + + spin_lock_irqsave(&jpeg->hw_lock, flags); + mtk_jpeg_dec_reset(jpeg->reg_base); + mtk_jpeg_dec_set_config(jpeg->reg_base, + &jpeg_src_buf->dec_param, &bs, &fb); + + mtk_jpeg_dec_start(jpeg->reg_base); + spin_unlock_irqrestore(&jpeg->hw_lock, flags); + return; + +dec_end: + v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); +} + +static int mtk_jpeg_dec_job_ready(void *priv) +{ + struct mtk_jpeg_ctx *ctx = priv; + + return (ctx->state == MTK_JPEG_RUNNING) ? 1 : 0; +} + +static const struct v4l2_m2m_ops mtk_jpeg_enc_m2m_ops = { + .device_run = mtk_jpeg_enc_device_run, +}; + +static const struct v4l2_m2m_ops mtk_jpeg_dec_m2m_ops = { + .device_run = mtk_jpeg_dec_device_run, + .job_ready = mtk_jpeg_dec_job_ready, +}; + +static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, + struct vb2_queue *dst_vq) +{ + struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + int ret; + + src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; + src_vq->io_modes = VB2_DMABUF | VB2_MMAP; + src_vq->drv_priv = ctx; + src_vq->buf_struct_size = sizeof(struct mtk_jpeg_src_buf); + src_vq->ops = jpeg->variant->qops; + src_vq->mem_ops = &vb2_dma_contig_memops; + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + src_vq->lock = &ctx->jpeg->lock; + src_vq->dev = ctx->jpeg->dev; + ret = vb2_queue_init(src_vq); + if (ret) + return ret; + + dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; + dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; + dst_vq->drv_priv = ctx; + dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); + dst_vq->ops = jpeg->variant->qops; + dst_vq->mem_ops = &vb2_dma_contig_memops; + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + dst_vq->lock = &ctx->jpeg->lock; + dst_vq->dev = ctx->jpeg->dev; + ret = vb2_queue_init(dst_vq); + + return ret; +} + +static void mtk_jpeg_clk_on(struct mtk_jpeg_dev *jpeg) +{ + int ret; + + ret = clk_bulk_prepare_enable(jpeg->variant->num_clks, + jpeg->variant->clks); + if (ret) + dev_err(jpeg->dev, "Failed to open jpeg clk: %d\n", ret); +} + +static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) +{ + clk_bulk_disable_unprepare(jpeg->variant->num_clks, + jpeg->variant->clks); +} + +static irqreturn_t mtk_jpeg_enc_done(struct mtk_jpeg_dev *jpeg) +{ + struct mtk_jpeg_ctx *ctx; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + u32 result_size; + + ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); + if (!ctx) { + v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); + return IRQ_HANDLED; + } + + src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + + result_size = mtk_jpeg_enc_get_file_size(jpeg->reg_base); + vb2_set_plane_payload(&dst_buf->vb2_buf, 0, result_size); + + buf_state = VB2_BUF_STATE_DONE; + + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); + pm_runtime_put(ctx->jpeg->dev); + return IRQ_HANDLED; +} + +static irqreturn_t mtk_jpeg_enc_irq(int irq, void *priv) +{ + struct mtk_jpeg_dev *jpeg = priv; + u32 irq_status; + irqreturn_t ret = IRQ_NONE; + + cancel_delayed_work(&jpeg->job_timeout_work); + + irq_status = readl(jpeg->reg_base + JPEG_ENC_INT_STS) & + JPEG_ENC_INT_STATUS_MASK_ALLIRQ; + if (irq_status) + writel(0, jpeg->reg_base + JPEG_ENC_INT_STS); + + if (!(irq_status & JPEG_ENC_INT_STATUS_DONE)) + return ret; + + ret = mtk_jpeg_enc_done(jpeg); + return ret; +} + +static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) +{ + struct mtk_jpeg_dev *jpeg = priv; + struct mtk_jpeg_ctx *ctx; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + struct mtk_jpeg_src_buf *jpeg_src_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + u32 dec_irq_ret; + u32 dec_ret; + int i; + + cancel_delayed_work(&jpeg->job_timeout_work); + + dec_ret = mtk_jpeg_dec_get_int_status(jpeg->reg_base); + dec_irq_ret = mtk_jpeg_dec_enum_result(dec_ret); + ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); + if (!ctx) { + v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); + return IRQ_HANDLED; + } + + src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); + + if (dec_irq_ret >= MTK_JPEG_DEC_RESULT_UNDERFLOW) + mtk_jpeg_dec_reset(jpeg->reg_base); + + if (dec_irq_ret != MTK_JPEG_DEC_RESULT_EOF_DONE) { + dev_err(jpeg->dev, "decode failed\n"); + goto dec_end; + } + + for (i = 0; i < dst_buf->vb2_buf.num_planes; i++) + vb2_set_plane_payload(&dst_buf->vb2_buf, i, + jpeg_src_buf->dec_param.comp_size[i]); + + buf_state = VB2_BUF_STATE_DONE; + +dec_end: + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); + pm_runtime_put(ctx->jpeg->dev); + return IRQ_HANDLED; +} + +static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) +{ + struct mtk_jpeg_q_data *q = &ctx->out_q; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + ctx->fh.ctrl_handler = &ctx->ctrl_hdl; + q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; + q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; + q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; + q->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; + + q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + jpeg->variant->out_q_default_fourcc, + MTK_JPEG_FMT_FLAG_OUTPUT); + q->pix_mp.width = MTK_JPEG_MIN_WIDTH; + q->pix_mp.height = MTK_JPEG_MIN_HEIGHT; + mtk_jpeg_try_fmt_mplane(&q->pix_mp, q->fmt); + + q = &ctx->cap_q; + q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, + jpeg->variant->num_formats, + jpeg->variant->cap_q_default_fourcc, + MTK_JPEG_FMT_FLAG_CAPTURE); + q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; + q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; + q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; + q->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; + q->pix_mp.width = MTK_JPEG_MIN_WIDTH; + q->pix_mp.height = MTK_JPEG_MIN_HEIGHT; + + mtk_jpeg_try_fmt_mplane(&q->pix_mp, q->fmt); +} + +static int mtk_jpeg_open(struct file *file) +{ + struct mtk_jpeg_dev *jpeg = video_drvdata(file); + struct video_device *vfd = video_devdata(file); + struct mtk_jpeg_ctx *ctx; + int ret = 0; + + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + if (mutex_lock_interruptible(&jpeg->lock)) { + ret = -ERESTARTSYS; + goto free; + } + + v4l2_fh_init(&ctx->fh, vfd); + file->private_data = &ctx->fh; + v4l2_fh_add(&ctx->fh); + + ctx->jpeg = jpeg; + ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, + mtk_jpeg_queue_init); + if (IS_ERR(ctx->fh.m2m_ctx)) { + ret = PTR_ERR(ctx->fh.m2m_ctx); + goto error; + } + + if (jpeg->variant->cap_q_default_fourcc == V4L2_PIX_FMT_JPEG) { + ret = mtk_jpeg_enc_ctrls_setup(ctx); + if (ret) { + v4l2_err(&jpeg->v4l2_dev, "Failed to setup jpeg enc controls\n"); + goto error; + } + } else { + v4l2_ctrl_handler_init(&ctx->ctrl_hdl, 0); + } + mtk_jpeg_set_default_params(ctx); + mutex_unlock(&jpeg->lock); + return 0; + +error: + v4l2_fh_del(&ctx->fh); + v4l2_fh_exit(&ctx->fh); + mutex_unlock(&jpeg->lock); +free: + kfree(ctx); + return ret; +} + +static int mtk_jpeg_release(struct file *file) +{ + struct mtk_jpeg_dev *jpeg = video_drvdata(file); + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(file->private_data); + + mutex_lock(&jpeg->lock); + v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); + v4l2_fh_del(&ctx->fh); + v4l2_fh_exit(&ctx->fh); + kfree(ctx); + mutex_unlock(&jpeg->lock); + return 0; +} + +static const struct v4l2_file_operations mtk_jpeg_fops = { + .owner = THIS_MODULE, + .open = mtk_jpeg_open, + .release = mtk_jpeg_release, + .poll = v4l2_m2m_fop_poll, + .unlocked_ioctl = video_ioctl2, + .mmap = v4l2_m2m_fop_mmap, +}; + +static struct clk_bulk_data mt8173_jpeg_dec_clocks[] = { + { .id = "jpgdec-smi" }, + { .id = "jpgdec" }, +}; + +static struct clk_bulk_data mtk_jpeg_clocks[] = { + { .id = "jpgenc" }, +}; + +static void mtk_jpeg_job_timeout_work(struct work_struct *work) +{ + struct mtk_jpeg_dev *jpeg = container_of(work, struct mtk_jpeg_dev, + job_timeout_work.work); + struct mtk_jpeg_ctx *ctx; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + + ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); + src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + + jpeg->variant->hw_reset(jpeg->reg_base); + + pm_runtime_put(jpeg->dev); + + v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR); + v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); +} + +static int mtk_jpeg_probe(struct platform_device *pdev) +{ + struct mtk_jpeg_dev *jpeg; + int jpeg_irq; + int ret; + + jpeg = devm_kzalloc(&pdev->dev, sizeof(*jpeg), GFP_KERNEL); + if (!jpeg) + return -ENOMEM; + + mutex_init(&jpeg->lock); + spin_lock_init(&jpeg->hw_lock); + jpeg->dev = &pdev->dev; + jpeg->variant = of_device_get_match_data(jpeg->dev); + INIT_DELAYED_WORK(&jpeg->job_timeout_work, mtk_jpeg_job_timeout_work); + + jpeg->reg_base = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(jpeg->reg_base)) { + ret = PTR_ERR(jpeg->reg_base); + return ret; + } + + jpeg_irq = platform_get_irq(pdev, 0); + if (jpeg_irq < 0) + return jpeg_irq; + + ret = devm_request_irq(&pdev->dev, jpeg_irq, + jpeg->variant->irq_handler, 0, pdev->name, jpeg); + if (ret) { + dev_err(&pdev->dev, "Failed to request jpeg_irq %d (%d)\n", + jpeg_irq, ret); + goto err_req_irq; + } + + ret = devm_clk_bulk_get(jpeg->dev, jpeg->variant->num_clks, + jpeg->variant->clks); + if (ret) { + dev_err(&pdev->dev, "Failed to init clk, err %d\n", ret); + goto err_clk_init; + } + + ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev); + if (ret) { + dev_err(&pdev->dev, "Failed to register v4l2 device\n"); + ret = -EINVAL; + goto err_dev_register; + } + + jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops); + + if (IS_ERR(jpeg->m2m_dev)) { + v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n"); + ret = PTR_ERR(jpeg->m2m_dev); + goto err_m2m_init; + } + + jpeg->vdev = video_device_alloc(); + if (!jpeg->vdev) { + ret = -ENOMEM; + goto err_vfd_jpeg_alloc; + } + snprintf(jpeg->vdev->name, sizeof(jpeg->vdev->name), + "%s", jpeg->variant->dev_name); + jpeg->vdev->fops = &mtk_jpeg_fops; + jpeg->vdev->ioctl_ops = jpeg->variant->ioctl_ops; + jpeg->vdev->minor = -1; + jpeg->vdev->release = video_device_release; + jpeg->vdev->lock = &jpeg->lock; + jpeg->vdev->v4l2_dev = &jpeg->v4l2_dev; + jpeg->vdev->vfl_dir = VFL_DIR_M2M; + jpeg->vdev->device_caps = V4L2_CAP_STREAMING | + V4L2_CAP_VIDEO_M2M_MPLANE; + + ret = video_register_device(jpeg->vdev, VFL_TYPE_VIDEO, -1); + if (ret) { + v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n"); + goto err_vfd_jpeg_register; + } + + video_set_drvdata(jpeg->vdev, jpeg); + v4l2_info(&jpeg->v4l2_dev, + "%s device registered as /dev/video%d (%d,%d)\n", + jpeg->variant->dev_name, jpeg->vdev->num, + VIDEO_MAJOR, jpeg->vdev->minor); + + platform_set_drvdata(pdev, jpeg); + + pm_runtime_enable(&pdev->dev); + + return 0; + +err_vfd_jpeg_register: + video_device_release(jpeg->vdev); + +err_vfd_jpeg_alloc: + v4l2_m2m_release(jpeg->m2m_dev); + +err_m2m_init: + v4l2_device_unregister(&jpeg->v4l2_dev); + +err_dev_register: + +err_clk_init: + +err_req_irq: + + return ret; +} + +static int mtk_jpeg_remove(struct platform_device *pdev) +{ + struct mtk_jpeg_dev *jpeg = platform_get_drvdata(pdev); + + pm_runtime_disable(&pdev->dev); + video_unregister_device(jpeg->vdev); + video_device_release(jpeg->vdev); + v4l2_m2m_release(jpeg->m2m_dev); + v4l2_device_unregister(&jpeg->v4l2_dev); + + return 0; +} + +static __maybe_unused int mtk_jpeg_pm_suspend(struct device *dev) +{ + struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); + + mtk_jpeg_clk_off(jpeg); + + return 0; +} + +static __maybe_unused int mtk_jpeg_pm_resume(struct device *dev) +{ + struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); + + mtk_jpeg_clk_on(jpeg); + + return 0; +} + +static __maybe_unused int mtk_jpeg_suspend(struct device *dev) +{ + struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); + + v4l2_m2m_suspend(jpeg->m2m_dev); + return pm_runtime_force_suspend(dev); +} + +static __maybe_unused int mtk_jpeg_resume(struct device *dev) +{ + struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); + int ret; + + ret = pm_runtime_force_resume(dev); + if (ret < 0) + return ret; + + v4l2_m2m_resume(jpeg->m2m_dev); + return ret; +} + +static const struct dev_pm_ops mtk_jpeg_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(mtk_jpeg_suspend, mtk_jpeg_resume) + SET_RUNTIME_PM_OPS(mtk_jpeg_pm_suspend, mtk_jpeg_pm_resume, NULL) +}; + +static const struct mtk_jpeg_variant mt8173_jpeg_drvdata = { + .clks = mt8173_jpeg_dec_clocks, + .num_clks = ARRAY_SIZE(mt8173_jpeg_dec_clocks), + .formats = mtk_jpeg_dec_formats, + .num_formats = MTK_JPEG_DEC_NUM_FORMATS, + .qops = &mtk_jpeg_dec_qops, + .irq_handler = mtk_jpeg_dec_irq, + .hw_reset = mtk_jpeg_dec_reset, + .m2m_ops = &mtk_jpeg_dec_m2m_ops, + .dev_name = "mtk-jpeg-dec", + .ioctl_ops = &mtk_jpeg_dec_ioctl_ops, + .out_q_default_fourcc = V4L2_PIX_FMT_JPEG, + .cap_q_default_fourcc = V4L2_PIX_FMT_YUV420M, +}; + +static const struct mtk_jpeg_variant mtk_jpeg_drvdata = { + .clks = mtk_jpeg_clocks, + .num_clks = ARRAY_SIZE(mtk_jpeg_clocks), + .formats = mtk_jpeg_enc_formats, + .num_formats = MTK_JPEG_ENC_NUM_FORMATS, + .qops = &mtk_jpeg_enc_qops, + .irq_handler = mtk_jpeg_enc_irq, + .hw_reset = mtk_jpeg_enc_reset, + .m2m_ops = &mtk_jpeg_enc_m2m_ops, + .dev_name = "mtk-jpeg-enc", + .ioctl_ops = &mtk_jpeg_enc_ioctl_ops, + .out_q_default_fourcc = V4L2_PIX_FMT_YUYV, + .cap_q_default_fourcc = V4L2_PIX_FMT_JPEG, +}; + +static const struct of_device_id mtk_jpeg_match[] = { + { + .compatible = "mediatek,mt8173-jpgdec", + .data = &mt8173_jpeg_drvdata, + }, + { + .compatible = "mediatek,mt2701-jpgdec", + .data = &mt8173_jpeg_drvdata, + }, + { + .compatible = "mediatek,mtk-jpgenc", + .data = &mtk_jpeg_drvdata, + }, + {}, +}; + +MODULE_DEVICE_TABLE(of, mtk_jpeg_match); + +static struct platform_driver mtk_jpeg_driver = { + .probe = mtk_jpeg_probe, + .remove = mtk_jpeg_remove, + .driver = { + .name = MTK_JPEG_NAME, + .of_match_table = mtk_jpeg_match, + .pm = &mtk_jpeg_pm_ops, + }, +}; + +module_platform_driver(mtk_jpeg_driver); + +MODULE_DESCRIPTION("MediaTek JPEG codec driver"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.h new file mode 100644 index 000000000000..3e4811a41ba2 --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_core.h @@ -0,0 +1,163 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + * Xia Jiang + */ + +#ifndef _MTK_JPEG_CORE_H +#define _MTK_JPEG_CORE_H + +#include +#include +#include +#include + +#define MTK_JPEG_NAME "mtk-jpeg" + +#define MTK_JPEG_COMP_MAX 3 + +#define MTK_JPEG_FMT_FLAG_OUTPUT BIT(0) +#define MTK_JPEG_FMT_FLAG_CAPTURE BIT(1) + +#define MTK_JPEG_MIN_WIDTH 32U +#define MTK_JPEG_MIN_HEIGHT 32U +#define MTK_JPEG_MAX_WIDTH 65535U +#define MTK_JPEG_MAX_HEIGHT 65535U + +#define MTK_JPEG_DEFAULT_SIZEIMAGE (1 * 1024 * 1024) + +#define MTK_JPEG_HW_TIMEOUT_MSEC 1000 + +#define MTK_JPEG_MAX_EXIF_SIZE (64 * 1024) + +/** + * enum mtk_jpeg_ctx_state - states of the context state machine + * @MTK_JPEG_INIT: current state is initialized + * @MTK_JPEG_RUNNING: current state is running + * @MTK_JPEG_SOURCE_CHANGE: current state is source resolution change + */ +enum mtk_jpeg_ctx_state { + MTK_JPEG_INIT = 0, + MTK_JPEG_RUNNING, + MTK_JPEG_SOURCE_CHANGE, +}; + +/** + * struct mtk_jpeg_variant - mtk jpeg driver variant + * @clks: clock names + * @num_clks: numbers of clock + * @formats: jpeg driver's internal color format + * @num_formats: number of formats + * @qops: the callback of jpeg vb2_ops + * @irq_handler: jpeg irq handler callback + * @hw_reset: jpeg hardware reset callback + * @m2m_ops: the callback of jpeg v4l2_m2m_ops + * @dev_name: jpeg device name + * @ioctl_ops: the callback of jpeg v4l2_ioctl_ops + * @out_q_default_fourcc: output queue default fourcc + * @cap_q_default_fourcc: capture queue default fourcc + */ +struct mtk_jpeg_variant { + struct clk_bulk_data *clks; + int num_clks; + struct mtk_jpeg_fmt *formats; + int num_formats; + const struct vb2_ops *qops; + irqreturn_t (*irq_handler)(int irq, void *priv); + void (*hw_reset)(void __iomem *base); + const struct v4l2_m2m_ops *m2m_ops; + const char *dev_name; + const struct v4l2_ioctl_ops *ioctl_ops; + u32 out_q_default_fourcc; + u32 cap_q_default_fourcc; +}; + +/** + * struct mtk_jpeg_dev - JPEG IP abstraction + * @lock: the mutex protecting this structure + * @hw_lock: spinlock protecting the hw device resource + * @workqueue: decode work queue + * @dev: JPEG device + * @v4l2_dev: v4l2 device for mem2mem mode + * @m2m_dev: v4l2 mem2mem device data + * @alloc_ctx: videobuf2 memory allocator's context + * @vdev: video device node for jpeg mem2mem mode + * @reg_base: JPEG registers mapping + * @job_timeout_work: IRQ timeout structure + * @variant: driver variant to be used + */ +struct mtk_jpeg_dev { + struct mutex lock; + spinlock_t hw_lock; + struct workqueue_struct *workqueue; + struct device *dev; + struct v4l2_device v4l2_dev; + struct v4l2_m2m_dev *m2m_dev; + void *alloc_ctx; + struct video_device *vdev; + void __iomem *reg_base; + struct delayed_work job_timeout_work; + const struct mtk_jpeg_variant *variant; +}; + +/** + * struct mtk_jpeg_fmt - driver's internal color format data + * @fourcc: the fourcc code, 0 if not applicable + * @hw_format: hardware format value + * @h_sample: horizontal sample count of plane in 4 * 4 pixel image + * @v_sample: vertical sample count of plane in 4 * 4 pixel image + * @colplanes: number of color planes (1 for packed formats) + * @h_align: horizontal alignment order (align to 2^h_align) + * @v_align: vertical alignment order (align to 2^v_align) + * @flags: flags describing format applicability + */ +struct mtk_jpeg_fmt { + u32 fourcc; + u32 hw_format; + int h_sample[VIDEO_MAX_PLANES]; + int v_sample[VIDEO_MAX_PLANES]; + int colplanes; + int h_align; + int v_align; + u32 flags; +}; + +/** + * struct mtk_jpeg_q_data - parameters of one queue + * @fmt: driver-specific format of this queue + * @pix_mp: multiplanar format + * @enc_crop_rect: jpeg encoder crop information + */ +struct mtk_jpeg_q_data { + struct mtk_jpeg_fmt *fmt; + struct v4l2_pix_format_mplane pix_mp; + struct v4l2_rect enc_crop_rect; +}; + +/** + * struct mtk_jpeg_ctx - the device context data + * @jpeg: JPEG IP device for this context + * @out_q: source (output) queue information + * @cap_q: destination (capture) queue queue information + * @fh: V4L2 file handle + * @state: state of the context + * @enable_exif: enable exif mode of jpeg encoder + * @enc_quality: jpeg encoder quality + * @restart_interval: jpeg encoder restart interval + * @ctrl_hdl: controls handler + */ +struct mtk_jpeg_ctx { + struct mtk_jpeg_dev *jpeg; + struct mtk_jpeg_q_data out_q; + struct mtk_jpeg_q_data cap_q; + struct v4l2_fh fh; + enum mtk_jpeg_ctx_state state; + bool enable_exif; + u8 enc_quality; + u8 restart_interval; + struct v4l2_ctrl_handler ctrl_hdl; +}; + +#endif /* _MTK_JPEG_CORE_H */ diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.c b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.c new file mode 100644 index 000000000000..afbbfd5d02bc --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.c @@ -0,0 +1,409 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + */ + +#include +#include +#include + +#include "mtk_jpeg_dec_hw.h" + +#define MTK_JPEG_DUNUM_MASK(val) (((val) - 1) & 0x3) + +enum mtk_jpeg_color { + MTK_JPEG_COLOR_420 = 0x00221111, + MTK_JPEG_COLOR_422 = 0x00211111, + MTK_JPEG_COLOR_444 = 0x00111111, + MTK_JPEG_COLOR_422V = 0x00121111, + MTK_JPEG_COLOR_422X2 = 0x00412121, + MTK_JPEG_COLOR_422VX2 = 0x00222121, + MTK_JPEG_COLOR_400 = 0x00110000 +}; + +static inline int mtk_jpeg_verify_align(u32 val, int align, u32 reg) +{ + if (val & (align - 1)) { + pr_err("mtk-jpeg: write reg %x without %d align\n", reg, align); + return -1; + } + + return 0; +} + +static int mtk_jpeg_decide_format(struct mtk_jpeg_dec_param *param) +{ + param->src_color = (param->sampling_w[0] << 20) | + (param->sampling_h[0] << 16) | + (param->sampling_w[1] << 12) | + (param->sampling_h[1] << 8) | + (param->sampling_w[2] << 4) | + (param->sampling_h[2]); + + param->uv_brz_w = 0; + switch (param->src_color) { + case MTK_JPEG_COLOR_444: + param->uv_brz_w = 1; + param->dst_fourcc = V4L2_PIX_FMT_YUV422M; + break; + case MTK_JPEG_COLOR_422X2: + case MTK_JPEG_COLOR_422: + param->dst_fourcc = V4L2_PIX_FMT_YUV422M; + break; + case MTK_JPEG_COLOR_422V: + case MTK_JPEG_COLOR_422VX2: + param->uv_brz_w = 1; + param->dst_fourcc = V4L2_PIX_FMT_YUV420M; + break; + case MTK_JPEG_COLOR_420: + param->dst_fourcc = V4L2_PIX_FMT_YUV420M; + break; + case MTK_JPEG_COLOR_400: + param->dst_fourcc = V4L2_PIX_FMT_GREY; + break; + default: + param->dst_fourcc = 0; + return -1; + } + + return 0; +} + +static void mtk_jpeg_calc_mcu(struct mtk_jpeg_dec_param *param) +{ + u32 factor_w, factor_h; + u32 i, comp, blk; + + factor_w = 2 + param->sampling_w[0]; + factor_h = 2 + param->sampling_h[0]; + param->mcu_w = (param->pic_w + (1 << factor_w) - 1) >> factor_w; + param->mcu_h = (param->pic_h + (1 << factor_h) - 1) >> factor_h; + param->total_mcu = param->mcu_w * param->mcu_h; + param->unit_num = ((param->pic_w + 7) >> 3) * ((param->pic_h + 7) >> 3); + param->blk_num = 0; + for (i = 0; i < MTK_JPEG_COMP_MAX; i++) { + param->blk_comp[i] = 0; + if (i >= param->comp_num) + continue; + param->blk_comp[i] = param->sampling_w[i] * + param->sampling_h[i]; + param->blk_num += param->blk_comp[i]; + } + + param->membership = 0; + for (i = 0, blk = 0, comp = 0; i < MTK_JPEG_BLOCK_MAX; i++) { + if (i < param->blk_num && comp < param->comp_num) { + u32 tmp; + + tmp = (0x04 + (comp & 0x3)); + param->membership |= tmp << (i * 3); + if (++blk == param->blk_comp[comp]) { + comp++; + blk = 0; + } + } else { + param->membership |= 7 << (i * 3); + } + } +} + +static void mtk_jpeg_calc_dma_group(struct mtk_jpeg_dec_param *param) +{ + u32 factor_mcu = 3; + + if (param->src_color == MTK_JPEG_COLOR_444 && + param->dst_fourcc == V4L2_PIX_FMT_YUV422M) + factor_mcu = 4; + else if (param->src_color == MTK_JPEG_COLOR_422V && + param->dst_fourcc == V4L2_PIX_FMT_YUV420M) + factor_mcu = 4; + else if (param->src_color == MTK_JPEG_COLOR_422X2 && + param->dst_fourcc == V4L2_PIX_FMT_YUV422M) + factor_mcu = 2; + else if (param->src_color == MTK_JPEG_COLOR_400 || + (param->src_color & 0x0FFFF) == 0) + factor_mcu = 4; + + param->dma_mcu = 1 << factor_mcu; + param->dma_group = param->mcu_w / param->dma_mcu; + param->dma_last_mcu = param->mcu_w % param->dma_mcu; + if (param->dma_last_mcu) + param->dma_group++; + else + param->dma_last_mcu = param->dma_mcu; +} + +static int mtk_jpeg_calc_dst_size(struct mtk_jpeg_dec_param *param) +{ + u32 i, padding_w; + u32 ds_row_h[3]; + u32 brz_w[3]; + + brz_w[0] = 0; + brz_w[1] = param->uv_brz_w; + brz_w[2] = brz_w[1]; + + for (i = 0; i < param->comp_num; i++) { + if (brz_w[i] > 3) + return -1; + + padding_w = param->mcu_w * MTK_JPEG_DCTSIZE * + param->sampling_w[i]; + /* output format is 420/422 */ + param->comp_w[i] = padding_w >> brz_w[i]; + param->comp_w[i] = round_up(param->comp_w[i], + MTK_JPEG_DCTSIZE); + param->img_stride[i] = i ? round_up(param->comp_w[i], 16) + : round_up(param->comp_w[i], 32); + ds_row_h[i] = (MTK_JPEG_DCTSIZE * param->sampling_h[i]); + } + param->dec_w = param->img_stride[0]; + param->dec_h = ds_row_h[0] * param->mcu_h; + + for (i = 0; i < MTK_JPEG_COMP_MAX; i++) { + /* They must be equal in frame mode. */ + param->mem_stride[i] = param->img_stride[i]; + param->comp_size[i] = param->mem_stride[i] * ds_row_h[i] * + param->mcu_h; + } + + param->y_size = param->comp_size[0]; + param->uv_size = param->comp_size[1]; + param->dec_size = param->y_size + (param->uv_size << 1); + + return 0; +} + +int mtk_jpeg_dec_fill_param(struct mtk_jpeg_dec_param *param) +{ + if (mtk_jpeg_decide_format(param)) + return -1; + + mtk_jpeg_calc_mcu(param); + mtk_jpeg_calc_dma_group(param); + if (mtk_jpeg_calc_dst_size(param)) + return -2; + + return 0; +} + +u32 mtk_jpeg_dec_get_int_status(void __iomem *base) +{ + u32 ret; + + ret = readl(base + JPGDEC_REG_INTERRUPT_STATUS) & BIT_INQST_MASK_ALLIRQ; + if (ret) + writel(ret, base + JPGDEC_REG_INTERRUPT_STATUS); + + return ret; +} + +u32 mtk_jpeg_dec_enum_result(u32 irq_result) +{ + if (irq_result & BIT_INQST_MASK_EOF) + return MTK_JPEG_DEC_RESULT_EOF_DONE; + if (irq_result & BIT_INQST_MASK_PAUSE) + return MTK_JPEG_DEC_RESULT_PAUSE; + if (irq_result & BIT_INQST_MASK_UNDERFLOW) + return MTK_JPEG_DEC_RESULT_UNDERFLOW; + if (irq_result & BIT_INQST_MASK_OVERFLOW) + return MTK_JPEG_DEC_RESULT_OVERFLOW; + if (irq_result & BIT_INQST_MASK_ERROR_BS) + return MTK_JPEG_DEC_RESULT_ERROR_BS; + + return MTK_JPEG_DEC_RESULT_ERROR_UNKNOWN; +} + +void mtk_jpeg_dec_start(void __iomem *base) +{ + writel(0, base + JPGDEC_REG_TRIG); +} + +static void mtk_jpeg_dec_soft_reset(void __iomem *base) +{ + writel(0x0000FFFF, base + JPGDEC_REG_INTERRUPT_STATUS); + writel(0x00, base + JPGDEC_REG_RESET); + writel(0x01, base + JPGDEC_REG_RESET); +} + +static void mtk_jpeg_dec_hard_reset(void __iomem *base) +{ + writel(0x00, base + JPGDEC_REG_RESET); + writel(0x10, base + JPGDEC_REG_RESET); +} + +void mtk_jpeg_dec_reset(void __iomem *base) +{ + mtk_jpeg_dec_soft_reset(base); + mtk_jpeg_dec_hard_reset(base); +} + +static void mtk_jpeg_dec_set_brz_factor(void __iomem *base, u8 yscale_w, + u8 yscale_h, u8 uvscale_w, u8 uvscale_h) +{ + u32 val; + + val = (uvscale_h << 12) | (uvscale_w << 8) | + (yscale_h << 4) | yscale_w; + writel(val, base + JPGDEC_REG_BRZ_FACTOR); +} + +static void mtk_jpeg_dec_set_dst_bank0(void __iomem *base, u32 addr_y, + u32 addr_u, u32 addr_v) +{ + mtk_jpeg_verify_align(addr_y, 16, JPGDEC_REG_DEST_ADDR0_Y); + writel(addr_y, base + JPGDEC_REG_DEST_ADDR0_Y); + mtk_jpeg_verify_align(addr_u, 16, JPGDEC_REG_DEST_ADDR0_U); + writel(addr_u, base + JPGDEC_REG_DEST_ADDR0_U); + mtk_jpeg_verify_align(addr_v, 16, JPGDEC_REG_DEST_ADDR0_V); + writel(addr_v, base + JPGDEC_REG_DEST_ADDR0_V); +} + +static void mtk_jpeg_dec_set_dst_bank1(void __iomem *base, u32 addr_y, + u32 addr_u, u32 addr_v) +{ + writel(addr_y, base + JPGDEC_REG_DEST_ADDR1_Y); + writel(addr_u, base + JPGDEC_REG_DEST_ADDR1_U); + writel(addr_v, base + JPGDEC_REG_DEST_ADDR1_V); +} + +static void mtk_jpeg_dec_set_mem_stride(void __iomem *base, u32 stride_y, + u32 stride_uv) +{ + writel((stride_y & 0xFFFF), base + JPGDEC_REG_STRIDE_Y); + writel((stride_uv & 0xFFFF), base + JPGDEC_REG_STRIDE_UV); +} + +static void mtk_jpeg_dec_set_img_stride(void __iomem *base, u32 stride_y, + u32 stride_uv) +{ + writel((stride_y & 0xFFFF), base + JPGDEC_REG_IMG_STRIDE_Y); + writel((stride_uv & 0xFFFF), base + JPGDEC_REG_IMG_STRIDE_UV); +} + +static void mtk_jpeg_dec_set_pause_mcu_idx(void __iomem *base, u32 idx) +{ + writel(idx & 0x0003FFFFFF, base + JPGDEC_REG_PAUSE_MCU_NUM); +} + +static void mtk_jpeg_dec_set_dec_mode(void __iomem *base, u32 mode) +{ + writel(mode & 0x03, base + JPGDEC_REG_OPERATION_MODE); +} + +static void mtk_jpeg_dec_set_bs_write_ptr(void __iomem *base, u32 ptr) +{ + mtk_jpeg_verify_align(ptr, 16, JPGDEC_REG_FILE_BRP); + writel(ptr, base + JPGDEC_REG_FILE_BRP); +} + +static void mtk_jpeg_dec_set_bs_info(void __iomem *base, u32 addr, u32 size) +{ + mtk_jpeg_verify_align(addr, 16, JPGDEC_REG_FILE_ADDR); + mtk_jpeg_verify_align(size, 128, JPGDEC_REG_FILE_TOTAL_SIZE); + writel(addr, base + JPGDEC_REG_FILE_ADDR); + writel(size, base + JPGDEC_REG_FILE_TOTAL_SIZE); +} + +static void mtk_jpeg_dec_set_comp_id(void __iomem *base, u32 id_y, u32 id_u, + u32 id_v) +{ + u32 val; + + val = ((id_y & 0x00FF) << 24) | ((id_u & 0x00FF) << 16) | + ((id_v & 0x00FF) << 8); + writel(val, base + JPGDEC_REG_COMP_ID); +} + +static void mtk_jpeg_dec_set_total_mcu(void __iomem *base, u32 num) +{ + writel(num - 1, base + JPGDEC_REG_TOTAL_MCU_NUM); +} + +static void mtk_jpeg_dec_set_comp0_du(void __iomem *base, u32 num) +{ + writel(num - 1, base + JPGDEC_REG_COMP0_DATA_UNIT_NUM); +} + +static void mtk_jpeg_dec_set_du_membership(void __iomem *base, u32 member, + u32 gmc, u32 isgray) +{ + if (isgray) + member = 0x3FFFFFFC; + member |= (isgray << 31) | (gmc << 30); + writel(member, base + JPGDEC_REG_DU_CTRL); +} + +static void mtk_jpeg_dec_set_q_table(void __iomem *base, u32 id0, u32 id1, + u32 id2) +{ + u32 val; + + val = ((id0 & 0x0f) << 8) | ((id1 & 0x0f) << 4) | ((id2 & 0x0f) << 0); + writel(val, base + JPGDEC_REG_QT_ID); +} + +static void mtk_jpeg_dec_set_dma_group(void __iomem *base, u32 mcu_group, + u32 group_num, u32 last_mcu) +{ + u32 val; + + val = (((mcu_group - 1) & 0x00FF) << 16) | + (((group_num - 1) & 0x007F) << 8) | + ((last_mcu - 1) & 0x00FF); + writel(val, base + JPGDEC_REG_WDMA_CTRL); +} + +static void mtk_jpeg_dec_set_sampling_factor(void __iomem *base, u32 comp_num, + u32 y_w, u32 y_h, u32 u_w, + u32 u_h, u32 v_w, u32 v_h) +{ + u32 val; + u32 y_wh = (MTK_JPEG_DUNUM_MASK(y_w) << 2) | MTK_JPEG_DUNUM_MASK(y_h); + u32 u_wh = (MTK_JPEG_DUNUM_MASK(u_w) << 2) | MTK_JPEG_DUNUM_MASK(u_h); + u32 v_wh = (MTK_JPEG_DUNUM_MASK(v_w) << 2) | MTK_JPEG_DUNUM_MASK(v_h); + + if (comp_num == 1) + val = 0; + else + val = (y_wh << 8) | (u_wh << 4) | v_wh; + writel(val, base + JPGDEC_REG_DU_NUM); +} + +void mtk_jpeg_dec_set_config(void __iomem *base, + struct mtk_jpeg_dec_param *config, + struct mtk_jpeg_bs *bs, + struct mtk_jpeg_fb *fb) +{ + mtk_jpeg_dec_set_brz_factor(base, 0, 0, config->uv_brz_w, 0); + mtk_jpeg_dec_set_dec_mode(base, 0); + mtk_jpeg_dec_set_comp0_du(base, config->unit_num); + mtk_jpeg_dec_set_total_mcu(base, config->total_mcu); + mtk_jpeg_dec_set_bs_info(base, bs->str_addr, bs->size); + mtk_jpeg_dec_set_bs_write_ptr(base, bs->end_addr); + mtk_jpeg_dec_set_du_membership(base, config->membership, 1, + (config->comp_num == 1) ? 1 : 0); + mtk_jpeg_dec_set_comp_id(base, config->comp_id[0], config->comp_id[1], + config->comp_id[2]); + mtk_jpeg_dec_set_q_table(base, config->qtbl_num[0], + config->qtbl_num[1], config->qtbl_num[2]); + mtk_jpeg_dec_set_sampling_factor(base, config->comp_num, + config->sampling_w[0], + config->sampling_h[0], + config->sampling_w[1], + config->sampling_h[1], + config->sampling_w[2], + config->sampling_h[2]); + mtk_jpeg_dec_set_mem_stride(base, config->mem_stride[0], + config->mem_stride[1]); + mtk_jpeg_dec_set_img_stride(base, config->img_stride[0], + config->img_stride[1]); + mtk_jpeg_dec_set_dst_bank0(base, fb->plane_addr[0], + fb->plane_addr[1], fb->plane_addr[2]); + mtk_jpeg_dec_set_dst_bank1(base, 0, 0, 0); + mtk_jpeg_dec_set_dma_group(base, config->dma_mcu, config->dma_group, + config->dma_last_mcu); + mtk_jpeg_dec_set_pause_mcu_idx(base, config->total_mcu); +} diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.h b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.h new file mode 100644 index 000000000000..fa0d45fd7c34 --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_hw.h @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + * Xia Jiang + */ + +#ifndef _MTK_JPEG_DEC_HW_H +#define _MTK_JPEG_DEC_HW_H + +#include + +#include "mtk_jpeg_core.h" +#include "mtk_jpeg_dec_reg.h" + +enum { + MTK_JPEG_DEC_RESULT_EOF_DONE = 0, + MTK_JPEG_DEC_RESULT_PAUSE = 1, + MTK_JPEG_DEC_RESULT_UNDERFLOW = 2, + MTK_JPEG_DEC_RESULT_OVERFLOW = 3, + MTK_JPEG_DEC_RESULT_ERROR_BS = 4, + MTK_JPEG_DEC_RESULT_ERROR_UNKNOWN = 6 +}; + +struct mtk_jpeg_dec_param { + u32 pic_w; + u32 pic_h; + u32 dec_w; + u32 dec_h; + u32 src_color; + u32 dst_fourcc; + u32 mcu_w; + u32 mcu_h; + u32 total_mcu; + u32 unit_num; + u32 comp_num; + u32 comp_id[MTK_JPEG_COMP_MAX]; + u32 sampling_w[MTK_JPEG_COMP_MAX]; + u32 sampling_h[MTK_JPEG_COMP_MAX]; + u32 qtbl_num[MTK_JPEG_COMP_MAX]; + u32 blk_num; + u32 blk_comp[MTK_JPEG_COMP_MAX]; + u32 membership; + u32 dma_mcu; + u32 dma_group; + u32 dma_last_mcu; + u32 img_stride[MTK_JPEG_COMP_MAX]; + u32 mem_stride[MTK_JPEG_COMP_MAX]; + u32 comp_w[MTK_JPEG_COMP_MAX]; + u32 comp_size[MTK_JPEG_COMP_MAX]; + u32 y_size; + u32 uv_size; + u32 dec_size; + u8 uv_brz_w; +}; + +struct mtk_jpeg_bs { + dma_addr_t str_addr; + dma_addr_t end_addr; + size_t size; +}; + +struct mtk_jpeg_fb { + dma_addr_t plane_addr[MTK_JPEG_COMP_MAX]; + size_t size; +}; + +int mtk_jpeg_dec_fill_param(struct mtk_jpeg_dec_param *param); +u32 mtk_jpeg_dec_get_int_status(void __iomem *dec_reg_base); +u32 mtk_jpeg_dec_enum_result(u32 irq_result); +void mtk_jpeg_dec_set_config(void __iomem *base, + struct mtk_jpeg_dec_param *config, + struct mtk_jpeg_bs *bs, + struct mtk_jpeg_fb *fb); +void mtk_jpeg_dec_reset(void __iomem *dec_reg_base); +void mtk_jpeg_dec_start(void __iomem *dec_reg_base); + +#endif /* _MTK_JPEG_HW_H */ diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.c b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.c new file mode 100644 index 000000000000..b95c45791c29 --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.c @@ -0,0 +1,152 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + */ + +#include +#include + +#include "mtk_jpeg_dec_parse.h" + +#define TEM 0x01 +#define SOF0 0xc0 +#define RST 0xd0 +#define SOI 0xd8 +#define EOI 0xd9 + +struct mtk_jpeg_stream { + u8 *addr; + u32 size; + u32 curr; +}; + +static int read_byte(struct mtk_jpeg_stream *stream) +{ + if (stream->curr >= stream->size) + return -1; + return stream->addr[stream->curr++]; +} + +static int read_word_be(struct mtk_jpeg_stream *stream, u32 *word) +{ + u32 temp; + int byte; + + byte = read_byte(stream); + if (byte == -1) + return -1; + temp = byte << 8; + byte = read_byte(stream); + if (byte == -1) + return -1; + *word = (u32)byte | temp; + + return 0; +} + +static void read_skip(struct mtk_jpeg_stream *stream, long len) +{ + if (len <= 0) + return; + while (len--) + read_byte(stream); +} + +static bool mtk_jpeg_do_parse(struct mtk_jpeg_dec_param *param, u8 *src_addr_va, + u32 src_size) +{ + bool notfound = true; + struct mtk_jpeg_stream stream; + + stream.addr = src_addr_va; + stream.size = src_size; + stream.curr = 0; + + while (notfound) { + int i, length, byte; + u32 word; + + byte = read_byte(&stream); + if (byte == -1) + return false; + if (byte != 0xff) + continue; + do + byte = read_byte(&stream); + while (byte == 0xff); + if (byte == -1) + return false; + if (byte == 0) + continue; + + length = 0; + switch (byte) { + case SOF0: + /* length */ + if (read_word_be(&stream, &word)) + break; + + /* precision */ + if (read_byte(&stream) == -1) + break; + + if (read_word_be(&stream, &word)) + break; + param->pic_h = word; + + if (read_word_be(&stream, &word)) + break; + param->pic_w = word; + + param->comp_num = read_byte(&stream); + if (param->comp_num != 1 && param->comp_num != 3) + break; + + for (i = 0; i < param->comp_num; i++) { + param->comp_id[i] = read_byte(&stream); + if (param->comp_id[i] == -1) + break; + + /* sampling */ + byte = read_byte(&stream); + if (byte == -1) + break; + param->sampling_w[i] = (byte >> 4) & 0x0F; + param->sampling_h[i] = byte & 0x0F; + + param->qtbl_num[i] = read_byte(&stream); + if (param->qtbl_num[i] == -1) + break; + } + + notfound = !(i == param->comp_num); + break; + case RST ... RST + 7: + case SOI: + case EOI: + case TEM: + break; + default: + if (read_word_be(&stream, &word)) + break; + length = (long)word - 2; + read_skip(&stream, length); + break; + } + } + + return !notfound; +} + +bool mtk_jpeg_parse(struct mtk_jpeg_dec_param *param, u8 *src_addr_va, + u32 src_size) +{ + if (!mtk_jpeg_do_parse(param, src_addr_va, src_size)) + return false; + if (mtk_jpeg_dec_fill_param(param)) + return false; + + return true; +} diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.h b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.h new file mode 100644 index 000000000000..2918f15811f8 --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_parse.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + */ + +#ifndef _MTK_JPEG_PARSE_H +#define _MTK_JPEG_PARSE_H + +#include "mtk_jpeg_dec_hw.h" + +bool mtk_jpeg_parse(struct mtk_jpeg_dec_param *param, u8 *src_addr_va, + u32 src_size); + +#endif /* _MTK_JPEG_PARSE_H */ + diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_reg.h b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_reg.h new file mode 100644 index 000000000000..21ec8f96797f --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_dec_reg.h @@ -0,0 +1,49 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2016 MediaTek Inc. + * Author: Ming Hsiu Tsai + * Rick Chang + */ + +#ifndef _MTK_JPEG_REG_H +#define _MTK_JPEG_REG_H + +#define MTK_JPEG_BLOCK_MAX 10 +#define MTK_JPEG_DCTSIZE 8 + +#define BIT_INQST_MASK_ERROR_BS 0x20 +#define BIT_INQST_MASK_PAUSE 0x10 +#define BIT_INQST_MASK_OVERFLOW 0x04 +#define BIT_INQST_MASK_UNDERFLOW 0x02 +#define BIT_INQST_MASK_EOF 0x01 +#define BIT_INQST_MASK_ALLIRQ 0x37 + +#define JPGDEC_REG_RESET 0x0090 +#define JPGDEC_REG_BRZ_FACTOR 0x00f8 +#define JPGDEC_REG_DU_NUM 0x00fc +#define JPGDEC_REG_DEST_ADDR0_Y 0x0140 +#define JPGDEC_REG_DEST_ADDR0_U 0x0144 +#define JPGDEC_REG_DEST_ADDR0_V 0x0148 +#define JPGDEC_REG_DEST_ADDR1_Y 0x014c +#define JPGDEC_REG_DEST_ADDR1_U 0x0150 +#define JPGDEC_REG_DEST_ADDR1_V 0x0154 +#define JPGDEC_REG_STRIDE_Y 0x0158 +#define JPGDEC_REG_STRIDE_UV 0x015c +#define JPGDEC_REG_IMG_STRIDE_Y 0x0160 +#define JPGDEC_REG_IMG_STRIDE_UV 0x0164 +#define JPGDEC_REG_WDMA_CTRL 0x016c +#define JPGDEC_REG_PAUSE_MCU_NUM 0x0170 +#define JPGDEC_REG_OPERATION_MODE 0x017c +#define JPGDEC_REG_FILE_ADDR 0x0200 +#define JPGDEC_REG_COMP_ID 0x020c +#define JPGDEC_REG_TOTAL_MCU_NUM 0x0210 +#define JPGDEC_REG_COMP0_DATA_UNIT_NUM 0x0224 +#define JPGDEC_REG_DU_CTRL 0x023c +#define JPGDEC_REG_TRIG 0x0240 +#define JPGDEC_REG_FILE_BRP 0x0248 +#define JPGDEC_REG_FILE_TOTAL_SIZE 0x024c +#define JPGDEC_REG_QT_ID 0x0270 +#define JPGDEC_REG_INTERRUPT_STATUS 0x0274 +#define JPGDEC_REG_STATUS 0x0278 + +#endif /* _MTK_JPEG_REG_H */ diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.c b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.c new file mode 100644 index 000000000000..1cf037bf72dd --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.c @@ -0,0 +1,154 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2019 MediaTek Inc. + * Author: Xia Jiang + * + */ + +#include +#include +#include +#include + +#include "mtk_jpeg_enc_hw.h" + +static const struct mtk_jpeg_enc_qlt mtk_jpeg_enc_quality[] = { + {.quality_param = 34, .hardware_value = JPEG_ENC_QUALITY_Q34}, + {.quality_param = 39, .hardware_value = JPEG_ENC_QUALITY_Q39}, + {.quality_param = 48, .hardware_value = JPEG_ENC_QUALITY_Q48}, + {.quality_param = 60, .hardware_value = JPEG_ENC_QUALITY_Q60}, + {.quality_param = 64, .hardware_value = JPEG_ENC_QUALITY_Q64}, + {.quality_param = 68, .hardware_value = JPEG_ENC_QUALITY_Q68}, + {.quality_param = 74, .hardware_value = JPEG_ENC_QUALITY_Q74}, + {.quality_param = 80, .hardware_value = JPEG_ENC_QUALITY_Q80}, + {.quality_param = 82, .hardware_value = JPEG_ENC_QUALITY_Q82}, + {.quality_param = 84, .hardware_value = JPEG_ENC_QUALITY_Q84}, + {.quality_param = 87, .hardware_value = JPEG_ENC_QUALITY_Q87}, + {.quality_param = 90, .hardware_value = JPEG_ENC_QUALITY_Q90}, + {.quality_param = 92, .hardware_value = JPEG_ENC_QUALITY_Q92}, + {.quality_param = 95, .hardware_value = JPEG_ENC_QUALITY_Q95}, + {.quality_param = 97, .hardware_value = JPEG_ENC_QUALITY_Q97}, +}; + +void mtk_jpeg_enc_reset(void __iomem *base) +{ + writel(0, base + JPEG_ENC_RSTB); + writel(JPEG_ENC_RESET_BIT, base + JPEG_ENC_RSTB); + writel(0, base + JPEG_ENC_CODEC_SEL); +} + +u32 mtk_jpeg_enc_get_file_size(void __iomem *base) +{ + return readl(base + JPEG_ENC_DMA_ADDR0) - + readl(base + JPEG_ENC_DST_ADDR0); +} + +void mtk_jpeg_enc_start(void __iomem *base) +{ + u32 value; + + value = readl(base + JPEG_ENC_CTRL); + value |= JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT; + writel(value, base + JPEG_ENC_CTRL); +} + +void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *src_buf) +{ + int i; + dma_addr_t dma_addr; + + for (i = 0; i < src_buf->num_planes; i++) { + dma_addr = vb2_dma_contig_plane_dma_addr(src_buf, i) + + src_buf->planes[i].data_offset; + if (!i) + writel(dma_addr, base + JPEG_ENC_SRC_LUMA_ADDR); + else + writel(dma_addr, base + JPEG_ENC_SRC_CHROMA_ADDR); + } +} + +void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *dst_buf) +{ + dma_addr_t dma_addr; + size_t size; + u32 dma_addr_offset; + u32 dma_addr_offsetmask; + + dma_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0); + dma_addr_offset = ctx->enable_exif ? MTK_JPEG_MAX_EXIF_SIZE : 0; + dma_addr_offsetmask = dma_addr & JPEG_ENC_DST_ADDR_OFFSET_MASK; + size = vb2_plane_size(dst_buf, 0); + + writel(dma_addr_offset & ~0xf, base + JPEG_ENC_OFFSET_ADDR); + writel(dma_addr_offsetmask & 0xf, base + JPEG_ENC_BYTE_OFFSET_MASK); + writel(dma_addr & ~0xf, base + JPEG_ENC_DST_ADDR0); + writel((dma_addr + size) & ~0xf, base + JPEG_ENC_STALL_ADDR0); +} + +void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base) +{ + u32 value; + u32 width = ctx->out_q.enc_crop_rect.width; + u32 height = ctx->out_q.enc_crop_rect.height; + u32 enc_format = ctx->out_q.fmt->fourcc; + u32 bytesperline = ctx->out_q.pix_mp.plane_fmt[0].bytesperline; + u32 blk_num; + u32 img_stride; + u32 mem_stride; + u32 i, enc_quality; + + value = width << 16 | height; + writel(value, base + JPEG_ENC_IMG_SIZE); + + if (enc_format == V4L2_PIX_FMT_NV12M || + enc_format == V4L2_PIX_FMT_NV21M) + /* + * Total 8 x 8 block number of luma and chroma. + * The number of blocks is counted from 0. + */ + blk_num = DIV_ROUND_UP(width, 16) * + DIV_ROUND_UP(height, 16) * 6 - 1; + else + blk_num = DIV_ROUND_UP(width, 16) * + DIV_ROUND_UP(height, 8) * 4 - 1; + writel(blk_num, base + JPEG_ENC_BLK_NUM); + + if (enc_format == V4L2_PIX_FMT_NV12M || + enc_format == V4L2_PIX_FMT_NV21M) { + /* 4:2:0 */ + img_stride = round_up(width, 16); + mem_stride = bytesperline; + } else { + /* 4:2:2 */ + img_stride = round_up(width * 2, 32); + mem_stride = img_stride; + } + writel(img_stride, base + JPEG_ENC_IMG_STRIDE); + writel(mem_stride, base + JPEG_ENC_STRIDE); + + enc_quality = mtk_jpeg_enc_quality[0].hardware_value; + for (i = 0; i < ARRAY_SIZE(mtk_jpeg_enc_quality); i++) { + if (ctx->enc_quality <= mtk_jpeg_enc_quality[i].quality_param) { + enc_quality = mtk_jpeg_enc_quality[i].hardware_value; + break; + } + } + writel(enc_quality, base + JPEG_ENC_QUALITY); + + value = readl(base + JPEG_ENC_CTRL); + value &= ~JPEG_ENC_CTRL_YUV_FORMAT_MASK; + value |= (ctx->out_q.fmt->hw_format & 3) << 3; + if (ctx->enable_exif) + value |= JPEG_ENC_CTRL_FILE_FORMAT_BIT; + else + value &= ~JPEG_ENC_CTRL_FILE_FORMAT_BIT; + if (ctx->restart_interval) + value |= JPEG_ENC_CTRL_RESTART_EN_BIT; + else + value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT; + writel(value, base + JPEG_ENC_CTRL); + + writel(ctx->restart_interval, base + JPEG_ENC_RST_MCU_NUM); +} diff --git a/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.h b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.h new file mode 100644 index 000000000000..61c60e4e58ea --- /dev/null +++ b/drivers/media/platform/mediatek/mtk-jpeg/mtk_jpeg_enc_hw.h @@ -0,0 +1,91 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2019 MediaTek Inc. + * Author: Xia Jiang + * + */ + +#ifndef _MTK_JPEG_ENC_HW_H +#define _MTK_JPEG_ENC_HW_H + +#include + +#include "mtk_jpeg_core.h" + +#define JPEG_ENC_INT_STATUS_DONE BIT(0) +#define JPEG_ENC_INT_STATUS_MASK_ALLIRQ 0x13 + +#define JPEG_ENC_DST_ADDR_OFFSET_MASK GENMASK(3, 0) + +#define JPEG_ENC_CTRL_YUV_FORMAT_MASK 0x18 +#define JPEG_ENC_CTRL_RESTART_EN_BIT BIT(10) +#define JPEG_ENC_CTRL_FILE_FORMAT_BIT BIT(5) +#define JPEG_ENC_CTRL_INT_EN_BIT BIT(2) +#define JPEG_ENC_CTRL_ENABLE_BIT BIT(0) +#define JPEG_ENC_RESET_BIT BIT(0) + +#define JPEG_ENC_YUV_FORMAT_YUYV 0 +#define JPEG_ENC_YUV_FORMAT_YVYU 1 +#define JPEG_ENC_YUV_FORMAT_NV12 2 +#define JEPG_ENC_YUV_FORMAT_NV21 3 + +#define JPEG_ENC_QUALITY_Q60 0x0 +#define JPEG_ENC_QUALITY_Q80 0x1 +#define JPEG_ENC_QUALITY_Q90 0x2 +#define JPEG_ENC_QUALITY_Q95 0x3 +#define JPEG_ENC_QUALITY_Q39 0x4 +#define JPEG_ENC_QUALITY_Q68 0x5 +#define JPEG_ENC_QUALITY_Q84 0x6 +#define JPEG_ENC_QUALITY_Q92 0x7 +#define JPEG_ENC_QUALITY_Q48 0x8 +#define JPEG_ENC_QUALITY_Q74 0xa +#define JPEG_ENC_QUALITY_Q87 0xb +#define JPEG_ENC_QUALITY_Q34 0xc +#define JPEG_ENC_QUALITY_Q64 0xe +#define JPEG_ENC_QUALITY_Q82 0xf +#define JPEG_ENC_QUALITY_Q97 0x10 + +#define JPEG_ENC_RSTB 0x100 +#define JPEG_ENC_CTRL 0x104 +#define JPEG_ENC_QUALITY 0x108 +#define JPEG_ENC_BLK_NUM 0x10C +#define JPEG_ENC_BLK_CNT 0x110 +#define JPEG_ENC_INT_STS 0x11c +#define JPEG_ENC_DST_ADDR0 0x120 +#define JPEG_ENC_DMA_ADDR0 0x124 +#define JPEG_ENC_STALL_ADDR0 0x128 +#define JPEG_ENC_OFFSET_ADDR 0x138 +#define JPEG_ENC_RST_MCU_NUM 0x150 +#define JPEG_ENC_IMG_SIZE 0x154 +#define JPEG_ENC_DEBUG_INFO0 0x160 +#define JPEG_ENC_DEBUG_INFO1 0x164 +#define JPEG_ENC_TOTAL_CYCLE 0x168 +#define JPEG_ENC_BYTE_OFFSET_MASK 0x16c +#define JPEG_ENC_SRC_LUMA_ADDR 0x170 +#define JPEG_ENC_SRC_CHROMA_ADDR 0x174 +#define JPEG_ENC_STRIDE 0x178 +#define JPEG_ENC_IMG_STRIDE 0x17c +#define JPEG_ENC_DCM_CTRL 0x300 +#define JPEG_ENC_CODEC_SEL 0x314 +#define JPEG_ENC_ULTRA_THRES 0x318 + +/** + * struct mtk_jpeg_enc_qlt - JPEG encoder quality data + * @quality_param: quality value + * @hardware_value: hardware value of quality + */ +struct mtk_jpeg_enc_qlt { + u8 quality_param; + u8 hardware_value; +}; + +void mtk_jpeg_enc_reset(void __iomem *base); +u32 mtk_jpeg_enc_get_file_size(void __iomem *base); +void mtk_jpeg_enc_start(void __iomem *enc_reg_base); +void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *src_buf); +void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *dst_buf); +void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base); + +#endif /* _MTK_JPEG_ENC_HW_H */ diff --git a/drivers/media/platform/mtk-jpeg/Kconfig b/drivers/media/platform/mtk-jpeg/Kconfig deleted file mode 100644 index 72ed920b011a..000000000000 --- a/drivers/media/platform/mtk-jpeg/Kconfig +++ /dev/null @@ -1,16 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0-only -config VIDEO_MEDIATEK_JPEG - tristate "Mediatek JPEG Codec driver" - depends on V4L_MEM2MEM_DRIVERS - depends on MTK_IOMMU_V1 || MTK_IOMMU || COMPILE_TEST - depends on VIDEO_DEV && VIDEO_V4L2 - depends on ARCH_MEDIATEK || COMPILE_TEST - depends on MTK_SMI || (COMPILE_TEST && MTK_SMI=n) - select VIDEOBUF2_DMA_CONTIG - select V4L2_MEM2MEM_DEV - help - Mediatek jpeg codec driver provides HW capability to decode - JPEG format - - To compile this driver as a module, choose M here: the - module will be called mtk-jpeg diff --git a/drivers/media/platform/mtk-jpeg/Makefile b/drivers/media/platform/mtk-jpeg/Makefile deleted file mode 100644 index 76c33aad0f3f..000000000000 --- a/drivers/media/platform/mtk-jpeg/Makefile +++ /dev/null @@ -1,6 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0-only -mtk_jpeg-objs := mtk_jpeg_core.o \ - mtk_jpeg_dec_hw.o \ - mtk_jpeg_dec_parse.o \ - mtk_jpeg_enc_hw.o -obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk_jpeg.o diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c deleted file mode 100644 index ab5485dfc20c..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c +++ /dev/null @@ -1,1528 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - * Xia Jiang - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "mtk_jpeg_enc_hw.h" -#include "mtk_jpeg_dec_hw.h" -#include "mtk_jpeg_core.h" -#include "mtk_jpeg_dec_parse.h" - -static struct mtk_jpeg_fmt mtk_jpeg_enc_formats[] = { - { - .fourcc = V4L2_PIX_FMT_JPEG, - .colplanes = 1, - .flags = MTK_JPEG_FMT_FLAG_CAPTURE, - }, - { - .fourcc = V4L2_PIX_FMT_NV12M, - .hw_format = JPEG_ENC_YUV_FORMAT_NV12, - .h_sample = {4, 4}, - .v_sample = {4, 2}, - .colplanes = 2, - .h_align = 4, - .v_align = 4, - .flags = MTK_JPEG_FMT_FLAG_OUTPUT, - }, - { - .fourcc = V4L2_PIX_FMT_NV21M, - .hw_format = JEPG_ENC_YUV_FORMAT_NV21, - .h_sample = {4, 4}, - .v_sample = {4, 2}, - .colplanes = 2, - .h_align = 4, - .v_align = 4, - .flags = MTK_JPEG_FMT_FLAG_OUTPUT, - }, - { - .fourcc = V4L2_PIX_FMT_YUYV, - .hw_format = JPEG_ENC_YUV_FORMAT_YUYV, - .h_sample = {8}, - .v_sample = {4}, - .colplanes = 1, - .h_align = 5, - .v_align = 3, - .flags = MTK_JPEG_FMT_FLAG_OUTPUT, - }, - { - .fourcc = V4L2_PIX_FMT_YVYU, - .hw_format = JPEG_ENC_YUV_FORMAT_YVYU, - .h_sample = {8}, - .v_sample = {4}, - .colplanes = 1, - .h_align = 5, - .v_align = 3, - .flags = MTK_JPEG_FMT_FLAG_OUTPUT, - }, -}; - -static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { - { - .fourcc = V4L2_PIX_FMT_JPEG, - .colplanes = 1, - .flags = MTK_JPEG_FMT_FLAG_OUTPUT, - }, - { - .fourcc = V4L2_PIX_FMT_YUV420M, - .h_sample = {4, 2, 2}, - .v_sample = {4, 2, 2}, - .colplanes = 3, - .h_align = 5, - .v_align = 4, - .flags = MTK_JPEG_FMT_FLAG_CAPTURE, - }, - { - .fourcc = V4L2_PIX_FMT_YUV422M, - .h_sample = {4, 2, 2}, - .v_sample = {4, 4, 4}, - .colplanes = 3, - .h_align = 5, - .v_align = 3, - .flags = MTK_JPEG_FMT_FLAG_CAPTURE, - }, -}; - -#define MTK_JPEG_ENC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_enc_formats) -#define MTK_JPEG_DEC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_dec_formats) - -struct mtk_jpeg_src_buf { - struct vb2_v4l2_buffer b; - struct list_head list; - struct mtk_jpeg_dec_param dec_param; -}; - -static int debug; -module_param(debug, int, 0644); - -static inline struct mtk_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl) -{ - return container_of(ctrl->handler, struct mtk_jpeg_ctx, ctrl_hdl); -} - -static inline struct mtk_jpeg_ctx *mtk_jpeg_fh_to_ctx(struct v4l2_fh *fh) -{ - return container_of(fh, struct mtk_jpeg_ctx, fh); -} - -static inline struct mtk_jpeg_src_buf *mtk_jpeg_vb2_to_srcbuf( - struct vb2_buffer *vb) -{ - return container_of(to_vb2_v4l2_buffer(vb), struct mtk_jpeg_src_buf, b); -} - -static int mtk_jpeg_querycap(struct file *file, void *priv, - struct v4l2_capability *cap) -{ - struct mtk_jpeg_dev *jpeg = video_drvdata(file); - - strscpy(cap->driver, jpeg->variant->dev_name, sizeof(cap->driver)); - strscpy(cap->card, jpeg->variant->dev_name, sizeof(cap->card)); - snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", - dev_name(jpeg->dev)); - - return 0; -} - -static int vidioc_jpeg_enc_s_ctrl(struct v4l2_ctrl *ctrl) -{ - struct mtk_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); - - switch (ctrl->id) { - case V4L2_CID_JPEG_RESTART_INTERVAL: - ctx->restart_interval = ctrl->val; - break; - case V4L2_CID_JPEG_COMPRESSION_QUALITY: - ctx->enc_quality = ctrl->val; - break; - case V4L2_CID_JPEG_ACTIVE_MARKER: - ctx->enable_exif = ctrl->val & V4L2_JPEG_ACTIVE_MARKER_APP1; - break; - } - - return 0; -} - -static const struct v4l2_ctrl_ops mtk_jpeg_enc_ctrl_ops = { - .s_ctrl = vidioc_jpeg_enc_s_ctrl, -}; - -static int mtk_jpeg_enc_ctrls_setup(struct mtk_jpeg_ctx *ctx) -{ - const struct v4l2_ctrl_ops *ops = &mtk_jpeg_enc_ctrl_ops; - struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl; - - v4l2_ctrl_handler_init(handler, 3); - - v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, - 1, 0); - v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_COMPRESSION_QUALITY, 48, - 100, 1, 90); - v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_ACTIVE_MARKER, 0, - V4L2_JPEG_ACTIVE_MARKER_APP1, 0, 0); - - if (handler->error) { - v4l2_ctrl_handler_free(&ctx->ctrl_hdl); - return handler->error; - } - - v4l2_ctrl_handler_setup(&ctx->ctrl_hdl); - - return 0; -} - -static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, - struct v4l2_fmtdesc *f, u32 type) -{ - int i, num = 0; - - for (i = 0; i < n; ++i) { - if (mtk_jpeg_formats[i].flags & type) { - if (num == f->index) - break; - ++num; - } - } - - if (i >= n) - return -EINVAL; - - f->pixelformat = mtk_jpeg_formats[i].fourcc; - - return 0; -} - -static int mtk_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, - struct v4l2_fmtdesc *f) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - - return mtk_jpeg_enum_fmt(jpeg->variant->formats, - jpeg->variant->num_formats, f, - MTK_JPEG_FMT_FLAG_CAPTURE); -} - -static int mtk_jpeg_enum_fmt_vid_out(struct file *file, void *priv, - struct v4l2_fmtdesc *f) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - - return mtk_jpeg_enum_fmt(jpeg->variant->formats, - jpeg->variant->num_formats, f, - MTK_JPEG_FMT_FLAG_OUTPUT); -} - -static struct mtk_jpeg_q_data *mtk_jpeg_get_q_data(struct mtk_jpeg_ctx *ctx, - enum v4l2_buf_type type) -{ - if (V4L2_TYPE_IS_OUTPUT(type)) - return &ctx->out_q; - return &ctx->cap_q; -} - -static struct mtk_jpeg_fmt * -mtk_jpeg_find_format(struct mtk_jpeg_fmt *mtk_jpeg_formats, int num_formats, - u32 pixelformat, unsigned int fmt_type) -{ - unsigned int k; - struct mtk_jpeg_fmt *fmt; - - for (k = 0; k < num_formats; k++) { - fmt = &mtk_jpeg_formats[k]; - - if (fmt->fourcc == pixelformat && fmt->flags & fmt_type) - return fmt; - } - - return NULL; -} - -static int mtk_jpeg_try_fmt_mplane(struct v4l2_pix_format_mplane *pix_mp, - struct mtk_jpeg_fmt *fmt) -{ - int i; - - pix_mp->field = V4L2_FIELD_NONE; - - pix_mp->num_planes = fmt->colplanes; - pix_mp->pixelformat = fmt->fourcc; - - if (fmt->fourcc == V4L2_PIX_FMT_JPEG) { - struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[0]; - - pix_mp->height = clamp(pix_mp->height, MTK_JPEG_MIN_HEIGHT, - MTK_JPEG_MAX_HEIGHT); - pix_mp->width = clamp(pix_mp->width, MTK_JPEG_MIN_WIDTH, - MTK_JPEG_MAX_WIDTH); - - pfmt->bytesperline = 0; - /* Source size must be aligned to 128 */ - pfmt->sizeimage = round_up(pfmt->sizeimage, 128); - if (pfmt->sizeimage == 0) - pfmt->sizeimage = MTK_JPEG_DEFAULT_SIZEIMAGE; - return 0; - } - - /* other fourcc */ - pix_mp->height = clamp(round_up(pix_mp->height, fmt->v_align), - MTK_JPEG_MIN_HEIGHT, MTK_JPEG_MAX_HEIGHT); - pix_mp->width = clamp(round_up(pix_mp->width, fmt->h_align), - MTK_JPEG_MIN_WIDTH, MTK_JPEG_MAX_WIDTH); - - for (i = 0; i < fmt->colplanes; i++) { - struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[i]; - u32 stride = pix_mp->width * fmt->h_sample[i] / 4; - u32 h = pix_mp->height * fmt->v_sample[i] / 4; - - pfmt->bytesperline = stride; - pfmt->sizeimage = stride * h; - } - return 0; -} - -static int mtk_jpeg_g_fmt_vid_mplane(struct file *file, void *priv, - struct v4l2_format *f) -{ - struct vb2_queue *vq; - struct mtk_jpeg_q_data *q_data = NULL; - struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - int i; - - vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); - if (!vq) - return -EINVAL; - - q_data = mtk_jpeg_get_q_data(ctx, f->type); - - pix_mp->width = q_data->pix_mp.width; - pix_mp->height = q_data->pix_mp.height; - pix_mp->field = V4L2_FIELD_NONE; - pix_mp->pixelformat = q_data->fmt->fourcc; - pix_mp->num_planes = q_data->fmt->colplanes; - pix_mp->colorspace = q_data->pix_mp.colorspace; - pix_mp->ycbcr_enc = q_data->pix_mp.ycbcr_enc; - pix_mp->xfer_func = q_data->pix_mp.xfer_func; - pix_mp->quantization = q_data->pix_mp.quantization; - - v4l2_dbg(1, debug, &jpeg->v4l2_dev, "(%d) g_fmt:%c%c%c%c wxh:%ux%u\n", - f->type, - (pix_mp->pixelformat & 0xff), - (pix_mp->pixelformat >> 8 & 0xff), - (pix_mp->pixelformat >> 16 & 0xff), - (pix_mp->pixelformat >> 24 & 0xff), - pix_mp->width, pix_mp->height); - - for (i = 0; i < pix_mp->num_planes; i++) { - struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[i]; - - pfmt->bytesperline = q_data->pix_mp.plane_fmt[i].bytesperline; - pfmt->sizeimage = q_data->pix_mp.plane_fmt[i].sizeimage; - - v4l2_dbg(1, debug, &jpeg->v4l2_dev, - "plane[%d] bpl=%u, size=%u\n", - i, - pfmt->bytesperline, - pfmt->sizeimage); - } - return 0; -} - -static int mtk_jpeg_try_fmt_vid_cap_mplane(struct file *file, void *priv, - struct v4l2_format *f) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct mtk_jpeg_fmt *fmt; - - fmt = mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, - f->fmt.pix_mp.pixelformat, - MTK_JPEG_FMT_FLAG_CAPTURE); - if (!fmt) - fmt = ctx->cap_q.fmt; - - v4l2_dbg(2, debug, &ctx->jpeg->v4l2_dev, "(%d) try_fmt:%c%c%c%c\n", - f->type, - (fmt->fourcc & 0xff), - (fmt->fourcc >> 8 & 0xff), - (fmt->fourcc >> 16 & 0xff), - (fmt->fourcc >> 24 & 0xff)); - - if (ctx->state != MTK_JPEG_INIT) { - mtk_jpeg_g_fmt_vid_mplane(file, priv, f); - return 0; - } - - return mtk_jpeg_try_fmt_mplane(&f->fmt.pix_mp, fmt); -} - -static int mtk_jpeg_try_fmt_vid_out_mplane(struct file *file, void *priv, - struct v4l2_format *f) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct mtk_jpeg_fmt *fmt; - - fmt = mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, - f->fmt.pix_mp.pixelformat, - MTK_JPEG_FMT_FLAG_OUTPUT); - if (!fmt) - fmt = ctx->out_q.fmt; - - v4l2_dbg(2, debug, &ctx->jpeg->v4l2_dev, "(%d) try_fmt:%c%c%c%c\n", - f->type, - (fmt->fourcc & 0xff), - (fmt->fourcc >> 8 & 0xff), - (fmt->fourcc >> 16 & 0xff), - (fmt->fourcc >> 24 & 0xff)); - - if (ctx->state != MTK_JPEG_INIT) { - mtk_jpeg_g_fmt_vid_mplane(file, priv, f); - return 0; - } - - return mtk_jpeg_try_fmt_mplane(&f->fmt.pix_mp, fmt); -} - -static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, - struct v4l2_format *f, unsigned int fmt_type) -{ - struct vb2_queue *vq; - struct mtk_jpeg_q_data *q_data = NULL; - struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - int i; - - vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); - if (!vq) - return -EINVAL; - - q_data = mtk_jpeg_get_q_data(ctx, f->type); - - if (vb2_is_busy(vq)) { - v4l2_err(&jpeg->v4l2_dev, "queue busy\n"); - return -EBUSY; - } - - q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, - pix_mp->pixelformat, fmt_type); - q_data->pix_mp.width = pix_mp->width; - q_data->pix_mp.height = pix_mp->height; - q_data->enc_crop_rect.width = pix_mp->width; - q_data->enc_crop_rect.height = pix_mp->height; - q_data->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; - q_data->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; - q_data->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; - q_data->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; - - v4l2_dbg(1, debug, &jpeg->v4l2_dev, "(%d) s_fmt:%c%c%c%c wxh:%ux%u\n", - f->type, - (q_data->fmt->fourcc & 0xff), - (q_data->fmt->fourcc >> 8 & 0xff), - (q_data->fmt->fourcc >> 16 & 0xff), - (q_data->fmt->fourcc >> 24 & 0xff), - q_data->pix_mp.width, q_data->pix_mp.height); - - for (i = 0; i < q_data->fmt->colplanes; i++) { - q_data->pix_mp.plane_fmt[i].bytesperline = - pix_mp->plane_fmt[i].bytesperline; - q_data->pix_mp.plane_fmt[i].sizeimage = - pix_mp->plane_fmt[i].sizeimage; - - v4l2_dbg(1, debug, &jpeg->v4l2_dev, - "plane[%d] bpl=%u, size=%u\n", - i, q_data->pix_mp.plane_fmt[i].bytesperline, - q_data->pix_mp.plane_fmt[i].sizeimage); - } - - return 0; -} - -static int mtk_jpeg_s_fmt_vid_out_mplane(struct file *file, void *priv, - struct v4l2_format *f) -{ - int ret; - - ret = mtk_jpeg_try_fmt_vid_out_mplane(file, priv, f); - if (ret) - return ret; - - return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, - MTK_JPEG_FMT_FLAG_OUTPUT); -} - -static int mtk_jpeg_s_fmt_vid_cap_mplane(struct file *file, void *priv, - struct v4l2_format *f) -{ - int ret; - - ret = mtk_jpeg_try_fmt_vid_cap_mplane(file, priv, f); - if (ret) - return ret; - - return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, - MTK_JPEG_FMT_FLAG_CAPTURE); -} - -static void mtk_jpeg_queue_src_chg_event(struct mtk_jpeg_ctx *ctx) -{ - static const struct v4l2_event ev_src_ch = { - .type = V4L2_EVENT_SOURCE_CHANGE, - .u.src_change.changes = - V4L2_EVENT_SRC_CH_RESOLUTION, - }; - - v4l2_event_queue_fh(&ctx->fh, &ev_src_ch); -} - -static int mtk_jpeg_subscribe_event(struct v4l2_fh *fh, - const struct v4l2_event_subscription *sub) -{ - switch (sub->type) { - case V4L2_EVENT_SOURCE_CHANGE: - return v4l2_src_change_event_subscribe(fh, sub); - } - - return v4l2_ctrl_subscribe_event(fh, sub); -} - -static int mtk_jpeg_enc_g_selection(struct file *file, void *priv, - struct v4l2_selection *s) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - - if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) - return -EINVAL; - - switch (s->target) { - case V4L2_SEL_TGT_CROP: - s->r = ctx->out_q.enc_crop_rect; - break; - case V4L2_SEL_TGT_CROP_BOUNDS: - case V4L2_SEL_TGT_CROP_DEFAULT: - s->r.width = ctx->out_q.pix_mp.width; - s->r.height = ctx->out_q.pix_mp.height; - s->r.left = 0; - s->r.top = 0; - break; - default: - return -EINVAL; - } - return 0; -} - -static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, - struct v4l2_selection *s) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - - if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) - return -EINVAL; - - switch (s->target) { - case V4L2_SEL_TGT_COMPOSE: - case V4L2_SEL_TGT_COMPOSE_DEFAULT: - s->r.width = ctx->out_q.pix_mp.width; - s->r.height = ctx->out_q.pix_mp.height; - s->r.left = 0; - s->r.top = 0; - break; - case V4L2_SEL_TGT_COMPOSE_BOUNDS: - case V4L2_SEL_TGT_COMPOSE_PADDED: - s->r.width = ctx->cap_q.pix_mp.width; - s->r.height = ctx->cap_q.pix_mp.height; - s->r.left = 0; - s->r.top = 0; - break; - default: - return -EINVAL; - } - return 0; -} - -static int mtk_jpeg_enc_s_selection(struct file *file, void *priv, - struct v4l2_selection *s) -{ - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); - - if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) - return -EINVAL; - - switch (s->target) { - case V4L2_SEL_TGT_CROP: - s->r.left = 0; - s->r.top = 0; - s->r.width = min(s->r.width, ctx->out_q.pix_mp.width); - s->r.height = min(s->r.height, ctx->out_q.pix_mp.height); - ctx->out_q.enc_crop_rect = s->r; - break; - default: - return -EINVAL; - } - - return 0; -} - -static const struct v4l2_ioctl_ops mtk_jpeg_enc_ioctl_ops = { - .vidioc_querycap = mtk_jpeg_querycap, - .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, - .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, - .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, - .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, - .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, - .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, - .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, - .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, - .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, - .vidioc_subscribe_event = mtk_jpeg_subscribe_event, - .vidioc_g_selection = mtk_jpeg_enc_g_selection, - .vidioc_s_selection = mtk_jpeg_enc_s_selection, - - .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, - .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, - .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, - .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, - .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, - .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, - .vidioc_streamon = v4l2_m2m_ioctl_streamon, - .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, - - .vidioc_unsubscribe_event = v4l2_event_unsubscribe, -}; - -static const struct v4l2_ioctl_ops mtk_jpeg_dec_ioctl_ops = { - .vidioc_querycap = mtk_jpeg_querycap, - .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, - .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, - .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, - .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, - .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, - .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, - .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, - .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, - .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, - .vidioc_subscribe_event = mtk_jpeg_subscribe_event, - .vidioc_g_selection = mtk_jpeg_dec_g_selection, - - .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, - .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, - .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, - .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, - .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, - .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, - .vidioc_streamon = v4l2_m2m_ioctl_streamon, - .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, - - .vidioc_unsubscribe_event = v4l2_event_unsubscribe, -}; - -static int mtk_jpeg_queue_setup(struct vb2_queue *q, - unsigned int *num_buffers, - unsigned int *num_planes, - unsigned int sizes[], - struct device *alloc_ctxs[]) -{ - struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); - struct mtk_jpeg_q_data *q_data = NULL; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - int i; - - v4l2_dbg(1, debug, &jpeg->v4l2_dev, "(%d) buf_req count=%u\n", - q->type, *num_buffers); - - q_data = mtk_jpeg_get_q_data(ctx, q->type); - if (!q_data) - return -EINVAL; - - if (*num_planes) { - for (i = 0; i < *num_planes; i++) - if (sizes[i] < q_data->pix_mp.plane_fmt[i].sizeimage) - return -EINVAL; - return 0; - } - - *num_planes = q_data->fmt->colplanes; - for (i = 0; i < q_data->fmt->colplanes; i++) { - sizes[i] = q_data->pix_mp.plane_fmt[i].sizeimage; - v4l2_dbg(1, debug, &jpeg->v4l2_dev, "sizeimage[%d]=%u\n", - i, sizes[i]); - } - - return 0; -} - -static int mtk_jpeg_buf_prepare(struct vb2_buffer *vb) -{ - struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); - struct mtk_jpeg_q_data *q_data = NULL; - struct v4l2_plane_pix_format plane_fmt; - int i; - - q_data = mtk_jpeg_get_q_data(ctx, vb->vb2_queue->type); - if (!q_data) - return -EINVAL; - - for (i = 0; i < q_data->fmt->colplanes; i++) { - plane_fmt = q_data->pix_mp.plane_fmt[i]; - if (ctx->enable_exif && - q_data->fmt->fourcc == V4L2_PIX_FMT_JPEG) - vb2_set_plane_payload(vb, i, plane_fmt.sizeimage + - MTK_JPEG_MAX_EXIF_SIZE); - else - vb2_set_plane_payload(vb, i, plane_fmt.sizeimage); - } - - return 0; -} - -static bool mtk_jpeg_check_resolution_change(struct mtk_jpeg_ctx *ctx, - struct mtk_jpeg_dec_param *param) -{ - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct mtk_jpeg_q_data *q_data; - - q_data = &ctx->out_q; - if (q_data->pix_mp.width != param->pic_w || - q_data->pix_mp.height != param->pic_h) { - v4l2_dbg(1, debug, &jpeg->v4l2_dev, "Picture size change\n"); - return true; - } - - q_data = &ctx->cap_q; - if (q_data->fmt != - mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, param->dst_fourcc, - MTK_JPEG_FMT_FLAG_CAPTURE)) { - v4l2_dbg(1, debug, &jpeg->v4l2_dev, "format change\n"); - return true; - } - return false; -} - -static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, - struct mtk_jpeg_dec_param *param) -{ - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct mtk_jpeg_q_data *q_data; - int i; - - q_data = &ctx->out_q; - q_data->pix_mp.width = param->pic_w; - q_data->pix_mp.height = param->pic_h; - - q_data = &ctx->cap_q; - q_data->pix_mp.width = param->dec_w; - q_data->pix_mp.height = param->dec_h; - q_data->fmt = mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, - param->dst_fourcc, - MTK_JPEG_FMT_FLAG_CAPTURE); - - for (i = 0; i < q_data->fmt->colplanes; i++) { - q_data->pix_mp.plane_fmt[i].bytesperline = param->mem_stride[i]; - q_data->pix_mp.plane_fmt[i].sizeimage = param->comp_size[i]; - } - - v4l2_dbg(1, debug, &jpeg->v4l2_dev, - "set_parse cap:%c%c%c%c pic(%u, %u), buf(%u, %u)\n", - (param->dst_fourcc & 0xff), - (param->dst_fourcc >> 8 & 0xff), - (param->dst_fourcc >> 16 & 0xff), - (param->dst_fourcc >> 24 & 0xff), - param->pic_w, param->pic_h, - param->dec_w, param->dec_h); -} - -static void mtk_jpeg_enc_buf_queue(struct vb2_buffer *vb) -{ - struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - - v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", - vb->vb2_queue->type, vb->index, vb); - - v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); -} - -static void mtk_jpeg_dec_buf_queue(struct vb2_buffer *vb) -{ - struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); - struct mtk_jpeg_dec_param *param; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct mtk_jpeg_src_buf *jpeg_src_buf; - bool header_valid; - - v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", - vb->vb2_queue->type, vb->index, vb); - - if (vb->vb2_queue->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) - goto end; - - jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(vb); - param = &jpeg_src_buf->dec_param; - memset(param, 0, sizeof(*param)); - - header_valid = mtk_jpeg_parse(param, (u8 *)vb2_plane_vaddr(vb, 0), - vb2_get_plane_payload(vb, 0)); - if (!header_valid) { - v4l2_err(&jpeg->v4l2_dev, "Header invalid.\n"); - vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); - return; - } - - if (ctx->state == MTK_JPEG_INIT) { - struct vb2_queue *dst_vq = v4l2_m2m_get_vq( - ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); - - mtk_jpeg_queue_src_chg_event(ctx); - mtk_jpeg_set_queue_data(ctx, param); - ctx->state = vb2_is_streaming(dst_vq) ? - MTK_JPEG_SOURCE_CHANGE : MTK_JPEG_RUNNING; - } -end: - v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); -} - -static struct vb2_v4l2_buffer *mtk_jpeg_buf_remove(struct mtk_jpeg_ctx *ctx, - enum v4l2_buf_type type) -{ - if (V4L2_TYPE_IS_OUTPUT(type)) - return v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); - else - return v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); -} - -static void mtk_jpeg_enc_stop_streaming(struct vb2_queue *q) -{ - struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); - struct vb2_v4l2_buffer *vb; - - while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) - v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); -} - -static void mtk_jpeg_dec_stop_streaming(struct vb2_queue *q) -{ - struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); - struct vb2_v4l2_buffer *vb; - - /* - * STREAMOFF is an acknowledgment for source change event. - * Before STREAMOFF, we still have to return the old resolution and - * subsampling. Update capture queue when the stream is off. - */ - if (ctx->state == MTK_JPEG_SOURCE_CHANGE && - V4L2_TYPE_IS_CAPTURE(q->type)) { - struct mtk_jpeg_src_buf *src_buf; - - vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); - src_buf = mtk_jpeg_vb2_to_srcbuf(&vb->vb2_buf); - mtk_jpeg_set_queue_data(ctx, &src_buf->dec_param); - ctx->state = MTK_JPEG_RUNNING; - } else if (V4L2_TYPE_IS_OUTPUT(q->type)) { - ctx->state = MTK_JPEG_INIT; - } - - while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) - v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); -} - -static const struct vb2_ops mtk_jpeg_dec_qops = { - .queue_setup = mtk_jpeg_queue_setup, - .buf_prepare = mtk_jpeg_buf_prepare, - .buf_queue = mtk_jpeg_dec_buf_queue, - .wait_prepare = vb2_ops_wait_prepare, - .wait_finish = vb2_ops_wait_finish, - .stop_streaming = mtk_jpeg_dec_stop_streaming, -}; - -static const struct vb2_ops mtk_jpeg_enc_qops = { - .queue_setup = mtk_jpeg_queue_setup, - .buf_prepare = mtk_jpeg_buf_prepare, - .buf_queue = mtk_jpeg_enc_buf_queue, - .wait_prepare = vb2_ops_wait_prepare, - .wait_finish = vb2_ops_wait_finish, - .stop_streaming = mtk_jpeg_enc_stop_streaming, -}; - -static void mtk_jpeg_set_dec_src(struct mtk_jpeg_ctx *ctx, - struct vb2_buffer *src_buf, - struct mtk_jpeg_bs *bs) -{ - bs->str_addr = vb2_dma_contig_plane_dma_addr(src_buf, 0); - bs->end_addr = bs->str_addr + - round_up(vb2_get_plane_payload(src_buf, 0), 16); - bs->size = round_up(vb2_plane_size(src_buf, 0), 128); -} - -static int mtk_jpeg_set_dec_dst(struct mtk_jpeg_ctx *ctx, - struct mtk_jpeg_dec_param *param, - struct vb2_buffer *dst_buf, - struct mtk_jpeg_fb *fb) -{ - int i; - - if (param->comp_num != dst_buf->num_planes) { - dev_err(ctx->jpeg->dev, "plane number mismatch (%u != %u)\n", - param->comp_num, dst_buf->num_planes); - return -EINVAL; - } - - for (i = 0; i < dst_buf->num_planes; i++) { - if (vb2_plane_size(dst_buf, i) < param->comp_size[i]) { - dev_err(ctx->jpeg->dev, - "buffer size is underflow (%lu < %u)\n", - vb2_plane_size(dst_buf, 0), - param->comp_size[i]); - return -EINVAL; - } - fb->plane_addr[i] = vb2_dma_contig_plane_dma_addr(dst_buf, i); - } - - return 0; -} - -static void mtk_jpeg_enc_device_run(void *priv) -{ - struct mtk_jpeg_ctx *ctx = priv; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct vb2_v4l2_buffer *src_buf, *dst_buf; - enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; - unsigned long flags; - int ret; - - src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); - dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); - - ret = pm_runtime_resume_and_get(jpeg->dev); - if (ret < 0) - goto enc_end; - - schedule_delayed_work(&jpeg->job_timeout_work, - msecs_to_jiffies(MTK_JPEG_HW_TIMEOUT_MSEC)); - - spin_lock_irqsave(&jpeg->hw_lock, flags); - - /* - * Resetting the hardware every frame is to ensure that all the - * registers are cleared. This is a hardware requirement. - */ - mtk_jpeg_enc_reset(jpeg->reg_base); - - mtk_jpeg_set_enc_src(ctx, jpeg->reg_base, &src_buf->vb2_buf); - mtk_jpeg_set_enc_dst(ctx, jpeg->reg_base, &dst_buf->vb2_buf); - mtk_jpeg_set_enc_params(ctx, jpeg->reg_base); - mtk_jpeg_enc_start(jpeg->reg_base); - spin_unlock_irqrestore(&jpeg->hw_lock, flags); - return; - -enc_end: - v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); - v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - v4l2_m2m_buf_done(src_buf, buf_state); - v4l2_m2m_buf_done(dst_buf, buf_state); - v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); -} - -static void mtk_jpeg_dec_device_run(void *priv) -{ - struct mtk_jpeg_ctx *ctx = priv; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - struct vb2_v4l2_buffer *src_buf, *dst_buf; - enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; - unsigned long flags; - struct mtk_jpeg_src_buf *jpeg_src_buf; - struct mtk_jpeg_bs bs; - struct mtk_jpeg_fb fb; - int ret; - - src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); - dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); - jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); - - if (mtk_jpeg_check_resolution_change(ctx, &jpeg_src_buf->dec_param)) { - mtk_jpeg_queue_src_chg_event(ctx); - ctx->state = MTK_JPEG_SOURCE_CHANGE; - v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); - return; - } - - ret = pm_runtime_resume_and_get(jpeg->dev); - if (ret < 0) - goto dec_end; - - schedule_delayed_work(&jpeg->job_timeout_work, - msecs_to_jiffies(MTK_JPEG_HW_TIMEOUT_MSEC)); - - mtk_jpeg_set_dec_src(ctx, &src_buf->vb2_buf, &bs); - if (mtk_jpeg_set_dec_dst(ctx, &jpeg_src_buf->dec_param, &dst_buf->vb2_buf, &fb)) - goto dec_end; - - spin_lock_irqsave(&jpeg->hw_lock, flags); - mtk_jpeg_dec_reset(jpeg->reg_base); - mtk_jpeg_dec_set_config(jpeg->reg_base, - &jpeg_src_buf->dec_param, &bs, &fb); - - mtk_jpeg_dec_start(jpeg->reg_base); - spin_unlock_irqrestore(&jpeg->hw_lock, flags); - return; - -dec_end: - v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); - v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - v4l2_m2m_buf_done(src_buf, buf_state); - v4l2_m2m_buf_done(dst_buf, buf_state); - v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); -} - -static int mtk_jpeg_dec_job_ready(void *priv) -{ - struct mtk_jpeg_ctx *ctx = priv; - - return (ctx->state == MTK_JPEG_RUNNING) ? 1 : 0; -} - -static const struct v4l2_m2m_ops mtk_jpeg_enc_m2m_ops = { - .device_run = mtk_jpeg_enc_device_run, -}; - -static const struct v4l2_m2m_ops mtk_jpeg_dec_m2m_ops = { - .device_run = mtk_jpeg_dec_device_run, - .job_ready = mtk_jpeg_dec_job_ready, -}; - -static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, - struct vb2_queue *dst_vq) -{ - struct mtk_jpeg_ctx *ctx = priv; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - int ret; - - src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; - src_vq->io_modes = VB2_DMABUF | VB2_MMAP; - src_vq->drv_priv = ctx; - src_vq->buf_struct_size = sizeof(struct mtk_jpeg_src_buf); - src_vq->ops = jpeg->variant->qops; - src_vq->mem_ops = &vb2_dma_contig_memops; - src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; - src_vq->lock = &ctx->jpeg->lock; - src_vq->dev = ctx->jpeg->dev; - ret = vb2_queue_init(src_vq); - if (ret) - return ret; - - dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; - dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; - dst_vq->drv_priv = ctx; - dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); - dst_vq->ops = jpeg->variant->qops; - dst_vq->mem_ops = &vb2_dma_contig_memops; - dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; - dst_vq->lock = &ctx->jpeg->lock; - dst_vq->dev = ctx->jpeg->dev; - ret = vb2_queue_init(dst_vq); - - return ret; -} - -static void mtk_jpeg_clk_on(struct mtk_jpeg_dev *jpeg) -{ - int ret; - - ret = clk_bulk_prepare_enable(jpeg->variant->num_clks, - jpeg->variant->clks); - if (ret) - dev_err(jpeg->dev, "Failed to open jpeg clk: %d\n", ret); -} - -static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) -{ - clk_bulk_disable_unprepare(jpeg->variant->num_clks, - jpeg->variant->clks); -} - -static irqreturn_t mtk_jpeg_enc_done(struct mtk_jpeg_dev *jpeg) -{ - struct mtk_jpeg_ctx *ctx; - struct vb2_v4l2_buffer *src_buf, *dst_buf; - enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; - u32 result_size; - - ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); - if (!ctx) { - v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); - return IRQ_HANDLED; - } - - src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); - dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - - result_size = mtk_jpeg_enc_get_file_size(jpeg->reg_base); - vb2_set_plane_payload(&dst_buf->vb2_buf, 0, result_size); - - buf_state = VB2_BUF_STATE_DONE; - - v4l2_m2m_buf_done(src_buf, buf_state); - v4l2_m2m_buf_done(dst_buf, buf_state); - v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); - pm_runtime_put(ctx->jpeg->dev); - return IRQ_HANDLED; -} - -static irqreturn_t mtk_jpeg_enc_irq(int irq, void *priv) -{ - struct mtk_jpeg_dev *jpeg = priv; - u32 irq_status; - irqreturn_t ret = IRQ_NONE; - - cancel_delayed_work(&jpeg->job_timeout_work); - - irq_status = readl(jpeg->reg_base + JPEG_ENC_INT_STS) & - JPEG_ENC_INT_STATUS_MASK_ALLIRQ; - if (irq_status) - writel(0, jpeg->reg_base + JPEG_ENC_INT_STS); - - if (!(irq_status & JPEG_ENC_INT_STATUS_DONE)) - return ret; - - ret = mtk_jpeg_enc_done(jpeg); - return ret; -} - -static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) -{ - struct mtk_jpeg_dev *jpeg = priv; - struct mtk_jpeg_ctx *ctx; - struct vb2_v4l2_buffer *src_buf, *dst_buf; - struct mtk_jpeg_src_buf *jpeg_src_buf; - enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; - u32 dec_irq_ret; - u32 dec_ret; - int i; - - cancel_delayed_work(&jpeg->job_timeout_work); - - dec_ret = mtk_jpeg_dec_get_int_status(jpeg->reg_base); - dec_irq_ret = mtk_jpeg_dec_enum_result(dec_ret); - ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); - if (!ctx) { - v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); - return IRQ_HANDLED; - } - - src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); - dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); - - if (dec_irq_ret >= MTK_JPEG_DEC_RESULT_UNDERFLOW) - mtk_jpeg_dec_reset(jpeg->reg_base); - - if (dec_irq_ret != MTK_JPEG_DEC_RESULT_EOF_DONE) { - dev_err(jpeg->dev, "decode failed\n"); - goto dec_end; - } - - for (i = 0; i < dst_buf->vb2_buf.num_planes; i++) - vb2_set_plane_payload(&dst_buf->vb2_buf, i, - jpeg_src_buf->dec_param.comp_size[i]); - - buf_state = VB2_BUF_STATE_DONE; - -dec_end: - v4l2_m2m_buf_done(src_buf, buf_state); - v4l2_m2m_buf_done(dst_buf, buf_state); - v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); - pm_runtime_put(ctx->jpeg->dev); - return IRQ_HANDLED; -} - -static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) -{ - struct mtk_jpeg_q_data *q = &ctx->out_q; - struct mtk_jpeg_dev *jpeg = ctx->jpeg; - - ctx->fh.ctrl_handler = &ctx->ctrl_hdl; - q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; - q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; - q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; - q->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; - - q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, - jpeg->variant->out_q_default_fourcc, - MTK_JPEG_FMT_FLAG_OUTPUT); - q->pix_mp.width = MTK_JPEG_MIN_WIDTH; - q->pix_mp.height = MTK_JPEG_MIN_HEIGHT; - mtk_jpeg_try_fmt_mplane(&q->pix_mp, q->fmt); - - q = &ctx->cap_q; - q->fmt = mtk_jpeg_find_format(jpeg->variant->formats, - jpeg->variant->num_formats, - jpeg->variant->cap_q_default_fourcc, - MTK_JPEG_FMT_FLAG_CAPTURE); - q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; - q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; - q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; - q->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; - q->pix_mp.width = MTK_JPEG_MIN_WIDTH; - q->pix_mp.height = MTK_JPEG_MIN_HEIGHT; - - mtk_jpeg_try_fmt_mplane(&q->pix_mp, q->fmt); -} - -static int mtk_jpeg_open(struct file *file) -{ - struct mtk_jpeg_dev *jpeg = video_drvdata(file); - struct video_device *vfd = video_devdata(file); - struct mtk_jpeg_ctx *ctx; - int ret = 0; - - ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); - if (!ctx) - return -ENOMEM; - - if (mutex_lock_interruptible(&jpeg->lock)) { - ret = -ERESTARTSYS; - goto free; - } - - v4l2_fh_init(&ctx->fh, vfd); - file->private_data = &ctx->fh; - v4l2_fh_add(&ctx->fh); - - ctx->jpeg = jpeg; - ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, - mtk_jpeg_queue_init); - if (IS_ERR(ctx->fh.m2m_ctx)) { - ret = PTR_ERR(ctx->fh.m2m_ctx); - goto error; - } - - if (jpeg->variant->cap_q_default_fourcc == V4L2_PIX_FMT_JPEG) { - ret = mtk_jpeg_enc_ctrls_setup(ctx); - if (ret) { - v4l2_err(&jpeg->v4l2_dev, "Failed to setup jpeg enc controls\n"); - goto error; - } - } else { - v4l2_ctrl_handler_init(&ctx->ctrl_hdl, 0); - } - mtk_jpeg_set_default_params(ctx); - mutex_unlock(&jpeg->lock); - return 0; - -error: - v4l2_fh_del(&ctx->fh); - v4l2_fh_exit(&ctx->fh); - mutex_unlock(&jpeg->lock); -free: - kfree(ctx); - return ret; -} - -static int mtk_jpeg_release(struct file *file) -{ - struct mtk_jpeg_dev *jpeg = video_drvdata(file); - struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(file->private_data); - - mutex_lock(&jpeg->lock); - v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); - v4l2_ctrl_handler_free(&ctx->ctrl_hdl); - v4l2_fh_del(&ctx->fh); - v4l2_fh_exit(&ctx->fh); - kfree(ctx); - mutex_unlock(&jpeg->lock); - return 0; -} - -static const struct v4l2_file_operations mtk_jpeg_fops = { - .owner = THIS_MODULE, - .open = mtk_jpeg_open, - .release = mtk_jpeg_release, - .poll = v4l2_m2m_fop_poll, - .unlocked_ioctl = video_ioctl2, - .mmap = v4l2_m2m_fop_mmap, -}; - -static struct clk_bulk_data mt8173_jpeg_dec_clocks[] = { - { .id = "jpgdec-smi" }, - { .id = "jpgdec" }, -}; - -static struct clk_bulk_data mtk_jpeg_clocks[] = { - { .id = "jpgenc" }, -}; - -static void mtk_jpeg_job_timeout_work(struct work_struct *work) -{ - struct mtk_jpeg_dev *jpeg = container_of(work, struct mtk_jpeg_dev, - job_timeout_work.work); - struct mtk_jpeg_ctx *ctx; - struct vb2_v4l2_buffer *src_buf, *dst_buf; - - ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); - src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); - dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); - - jpeg->variant->hw_reset(jpeg->reg_base); - - pm_runtime_put(jpeg->dev); - - v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR); - v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR); - v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); -} - -static int mtk_jpeg_probe(struct platform_device *pdev) -{ - struct mtk_jpeg_dev *jpeg; - int jpeg_irq; - int ret; - - jpeg = devm_kzalloc(&pdev->dev, sizeof(*jpeg), GFP_KERNEL); - if (!jpeg) - return -ENOMEM; - - mutex_init(&jpeg->lock); - spin_lock_init(&jpeg->hw_lock); - jpeg->dev = &pdev->dev; - jpeg->variant = of_device_get_match_data(jpeg->dev); - INIT_DELAYED_WORK(&jpeg->job_timeout_work, mtk_jpeg_job_timeout_work); - - jpeg->reg_base = devm_platform_ioremap_resource(pdev, 0); - if (IS_ERR(jpeg->reg_base)) { - ret = PTR_ERR(jpeg->reg_base); - return ret; - } - - jpeg_irq = platform_get_irq(pdev, 0); - if (jpeg_irq < 0) - return jpeg_irq; - - ret = devm_request_irq(&pdev->dev, jpeg_irq, - jpeg->variant->irq_handler, 0, pdev->name, jpeg); - if (ret) { - dev_err(&pdev->dev, "Failed to request jpeg_irq %d (%d)\n", - jpeg_irq, ret); - goto err_req_irq; - } - - ret = devm_clk_bulk_get(jpeg->dev, jpeg->variant->num_clks, - jpeg->variant->clks); - if (ret) { - dev_err(&pdev->dev, "Failed to init clk, err %d\n", ret); - goto err_clk_init; - } - - ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev); - if (ret) { - dev_err(&pdev->dev, "Failed to register v4l2 device\n"); - ret = -EINVAL; - goto err_dev_register; - } - - jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops); - - if (IS_ERR(jpeg->m2m_dev)) { - v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n"); - ret = PTR_ERR(jpeg->m2m_dev); - goto err_m2m_init; - } - - jpeg->vdev = video_device_alloc(); - if (!jpeg->vdev) { - ret = -ENOMEM; - goto err_vfd_jpeg_alloc; - } - snprintf(jpeg->vdev->name, sizeof(jpeg->vdev->name), - "%s", jpeg->variant->dev_name); - jpeg->vdev->fops = &mtk_jpeg_fops; - jpeg->vdev->ioctl_ops = jpeg->variant->ioctl_ops; - jpeg->vdev->minor = -1; - jpeg->vdev->release = video_device_release; - jpeg->vdev->lock = &jpeg->lock; - jpeg->vdev->v4l2_dev = &jpeg->v4l2_dev; - jpeg->vdev->vfl_dir = VFL_DIR_M2M; - jpeg->vdev->device_caps = V4L2_CAP_STREAMING | - V4L2_CAP_VIDEO_M2M_MPLANE; - - ret = video_register_device(jpeg->vdev, VFL_TYPE_VIDEO, -1); - if (ret) { - v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n"); - goto err_vfd_jpeg_register; - } - - video_set_drvdata(jpeg->vdev, jpeg); - v4l2_info(&jpeg->v4l2_dev, - "%s device registered as /dev/video%d (%d,%d)\n", - jpeg->variant->dev_name, jpeg->vdev->num, - VIDEO_MAJOR, jpeg->vdev->minor); - - platform_set_drvdata(pdev, jpeg); - - pm_runtime_enable(&pdev->dev); - - return 0; - -err_vfd_jpeg_register: - video_device_release(jpeg->vdev); - -err_vfd_jpeg_alloc: - v4l2_m2m_release(jpeg->m2m_dev); - -err_m2m_init: - v4l2_device_unregister(&jpeg->v4l2_dev); - -err_dev_register: - -err_clk_init: - -err_req_irq: - - return ret; -} - -static int mtk_jpeg_remove(struct platform_device *pdev) -{ - struct mtk_jpeg_dev *jpeg = platform_get_drvdata(pdev); - - pm_runtime_disable(&pdev->dev); - video_unregister_device(jpeg->vdev); - video_device_release(jpeg->vdev); - v4l2_m2m_release(jpeg->m2m_dev); - v4l2_device_unregister(&jpeg->v4l2_dev); - - return 0; -} - -static __maybe_unused int mtk_jpeg_pm_suspend(struct device *dev) -{ - struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); - - mtk_jpeg_clk_off(jpeg); - - return 0; -} - -static __maybe_unused int mtk_jpeg_pm_resume(struct device *dev) -{ - struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); - - mtk_jpeg_clk_on(jpeg); - - return 0; -} - -static __maybe_unused int mtk_jpeg_suspend(struct device *dev) -{ - struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); - - v4l2_m2m_suspend(jpeg->m2m_dev); - return pm_runtime_force_suspend(dev); -} - -static __maybe_unused int mtk_jpeg_resume(struct device *dev) -{ - struct mtk_jpeg_dev *jpeg = dev_get_drvdata(dev); - int ret; - - ret = pm_runtime_force_resume(dev); - if (ret < 0) - return ret; - - v4l2_m2m_resume(jpeg->m2m_dev); - return ret; -} - -static const struct dev_pm_ops mtk_jpeg_pm_ops = { - SET_SYSTEM_SLEEP_PM_OPS(mtk_jpeg_suspend, mtk_jpeg_resume) - SET_RUNTIME_PM_OPS(mtk_jpeg_pm_suspend, mtk_jpeg_pm_resume, NULL) -}; - -static const struct mtk_jpeg_variant mt8173_jpeg_drvdata = { - .clks = mt8173_jpeg_dec_clocks, - .num_clks = ARRAY_SIZE(mt8173_jpeg_dec_clocks), - .formats = mtk_jpeg_dec_formats, - .num_formats = MTK_JPEG_DEC_NUM_FORMATS, - .qops = &mtk_jpeg_dec_qops, - .irq_handler = mtk_jpeg_dec_irq, - .hw_reset = mtk_jpeg_dec_reset, - .m2m_ops = &mtk_jpeg_dec_m2m_ops, - .dev_name = "mtk-jpeg-dec", - .ioctl_ops = &mtk_jpeg_dec_ioctl_ops, - .out_q_default_fourcc = V4L2_PIX_FMT_JPEG, - .cap_q_default_fourcc = V4L2_PIX_FMT_YUV420M, -}; - -static const struct mtk_jpeg_variant mtk_jpeg_drvdata = { - .clks = mtk_jpeg_clocks, - .num_clks = ARRAY_SIZE(mtk_jpeg_clocks), - .formats = mtk_jpeg_enc_formats, - .num_formats = MTK_JPEG_ENC_NUM_FORMATS, - .qops = &mtk_jpeg_enc_qops, - .irq_handler = mtk_jpeg_enc_irq, - .hw_reset = mtk_jpeg_enc_reset, - .m2m_ops = &mtk_jpeg_enc_m2m_ops, - .dev_name = "mtk-jpeg-enc", - .ioctl_ops = &mtk_jpeg_enc_ioctl_ops, - .out_q_default_fourcc = V4L2_PIX_FMT_YUYV, - .cap_q_default_fourcc = V4L2_PIX_FMT_JPEG, -}; - -static const struct of_device_id mtk_jpeg_match[] = { - { - .compatible = "mediatek,mt8173-jpgdec", - .data = &mt8173_jpeg_drvdata, - }, - { - .compatible = "mediatek,mt2701-jpgdec", - .data = &mt8173_jpeg_drvdata, - }, - { - .compatible = "mediatek,mtk-jpgenc", - .data = &mtk_jpeg_drvdata, - }, - {}, -}; - -MODULE_DEVICE_TABLE(of, mtk_jpeg_match); - -static struct platform_driver mtk_jpeg_driver = { - .probe = mtk_jpeg_probe, - .remove = mtk_jpeg_remove, - .driver = { - .name = MTK_JPEG_NAME, - .of_match_table = mtk_jpeg_match, - .pm = &mtk_jpeg_pm_ops, - }, -}; - -module_platform_driver(mtk_jpeg_driver); - -MODULE_DESCRIPTION("MediaTek JPEG codec driver"); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h deleted file mode 100644 index 3e4811a41ba2..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h +++ /dev/null @@ -1,163 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - * Xia Jiang - */ - -#ifndef _MTK_JPEG_CORE_H -#define _MTK_JPEG_CORE_H - -#include -#include -#include -#include - -#define MTK_JPEG_NAME "mtk-jpeg" - -#define MTK_JPEG_COMP_MAX 3 - -#define MTK_JPEG_FMT_FLAG_OUTPUT BIT(0) -#define MTK_JPEG_FMT_FLAG_CAPTURE BIT(1) - -#define MTK_JPEG_MIN_WIDTH 32U -#define MTK_JPEG_MIN_HEIGHT 32U -#define MTK_JPEG_MAX_WIDTH 65535U -#define MTK_JPEG_MAX_HEIGHT 65535U - -#define MTK_JPEG_DEFAULT_SIZEIMAGE (1 * 1024 * 1024) - -#define MTK_JPEG_HW_TIMEOUT_MSEC 1000 - -#define MTK_JPEG_MAX_EXIF_SIZE (64 * 1024) - -/** - * enum mtk_jpeg_ctx_state - states of the context state machine - * @MTK_JPEG_INIT: current state is initialized - * @MTK_JPEG_RUNNING: current state is running - * @MTK_JPEG_SOURCE_CHANGE: current state is source resolution change - */ -enum mtk_jpeg_ctx_state { - MTK_JPEG_INIT = 0, - MTK_JPEG_RUNNING, - MTK_JPEG_SOURCE_CHANGE, -}; - -/** - * struct mtk_jpeg_variant - mtk jpeg driver variant - * @clks: clock names - * @num_clks: numbers of clock - * @formats: jpeg driver's internal color format - * @num_formats: number of formats - * @qops: the callback of jpeg vb2_ops - * @irq_handler: jpeg irq handler callback - * @hw_reset: jpeg hardware reset callback - * @m2m_ops: the callback of jpeg v4l2_m2m_ops - * @dev_name: jpeg device name - * @ioctl_ops: the callback of jpeg v4l2_ioctl_ops - * @out_q_default_fourcc: output queue default fourcc - * @cap_q_default_fourcc: capture queue default fourcc - */ -struct mtk_jpeg_variant { - struct clk_bulk_data *clks; - int num_clks; - struct mtk_jpeg_fmt *formats; - int num_formats; - const struct vb2_ops *qops; - irqreturn_t (*irq_handler)(int irq, void *priv); - void (*hw_reset)(void __iomem *base); - const struct v4l2_m2m_ops *m2m_ops; - const char *dev_name; - const struct v4l2_ioctl_ops *ioctl_ops; - u32 out_q_default_fourcc; - u32 cap_q_default_fourcc; -}; - -/** - * struct mtk_jpeg_dev - JPEG IP abstraction - * @lock: the mutex protecting this structure - * @hw_lock: spinlock protecting the hw device resource - * @workqueue: decode work queue - * @dev: JPEG device - * @v4l2_dev: v4l2 device for mem2mem mode - * @m2m_dev: v4l2 mem2mem device data - * @alloc_ctx: videobuf2 memory allocator's context - * @vdev: video device node for jpeg mem2mem mode - * @reg_base: JPEG registers mapping - * @job_timeout_work: IRQ timeout structure - * @variant: driver variant to be used - */ -struct mtk_jpeg_dev { - struct mutex lock; - spinlock_t hw_lock; - struct workqueue_struct *workqueue; - struct device *dev; - struct v4l2_device v4l2_dev; - struct v4l2_m2m_dev *m2m_dev; - void *alloc_ctx; - struct video_device *vdev; - void __iomem *reg_base; - struct delayed_work job_timeout_work; - const struct mtk_jpeg_variant *variant; -}; - -/** - * struct mtk_jpeg_fmt - driver's internal color format data - * @fourcc: the fourcc code, 0 if not applicable - * @hw_format: hardware format value - * @h_sample: horizontal sample count of plane in 4 * 4 pixel image - * @v_sample: vertical sample count of plane in 4 * 4 pixel image - * @colplanes: number of color planes (1 for packed formats) - * @h_align: horizontal alignment order (align to 2^h_align) - * @v_align: vertical alignment order (align to 2^v_align) - * @flags: flags describing format applicability - */ -struct mtk_jpeg_fmt { - u32 fourcc; - u32 hw_format; - int h_sample[VIDEO_MAX_PLANES]; - int v_sample[VIDEO_MAX_PLANES]; - int colplanes; - int h_align; - int v_align; - u32 flags; -}; - -/** - * struct mtk_jpeg_q_data - parameters of one queue - * @fmt: driver-specific format of this queue - * @pix_mp: multiplanar format - * @enc_crop_rect: jpeg encoder crop information - */ -struct mtk_jpeg_q_data { - struct mtk_jpeg_fmt *fmt; - struct v4l2_pix_format_mplane pix_mp; - struct v4l2_rect enc_crop_rect; -}; - -/** - * struct mtk_jpeg_ctx - the device context data - * @jpeg: JPEG IP device for this context - * @out_q: source (output) queue information - * @cap_q: destination (capture) queue queue information - * @fh: V4L2 file handle - * @state: state of the context - * @enable_exif: enable exif mode of jpeg encoder - * @enc_quality: jpeg encoder quality - * @restart_interval: jpeg encoder restart interval - * @ctrl_hdl: controls handler - */ -struct mtk_jpeg_ctx { - struct mtk_jpeg_dev *jpeg; - struct mtk_jpeg_q_data out_q; - struct mtk_jpeg_q_data cap_q; - struct v4l2_fh fh; - enum mtk_jpeg_ctx_state state; - bool enable_exif; - u8 enc_quality; - u8 restart_interval; - struct v4l2_ctrl_handler ctrl_hdl; -}; - -#endif /* _MTK_JPEG_CORE_H */ diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.c deleted file mode 100644 index afbbfd5d02bc..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.c +++ /dev/null @@ -1,409 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - */ - -#include -#include -#include - -#include "mtk_jpeg_dec_hw.h" - -#define MTK_JPEG_DUNUM_MASK(val) (((val) - 1) & 0x3) - -enum mtk_jpeg_color { - MTK_JPEG_COLOR_420 = 0x00221111, - MTK_JPEG_COLOR_422 = 0x00211111, - MTK_JPEG_COLOR_444 = 0x00111111, - MTK_JPEG_COLOR_422V = 0x00121111, - MTK_JPEG_COLOR_422X2 = 0x00412121, - MTK_JPEG_COLOR_422VX2 = 0x00222121, - MTK_JPEG_COLOR_400 = 0x00110000 -}; - -static inline int mtk_jpeg_verify_align(u32 val, int align, u32 reg) -{ - if (val & (align - 1)) { - pr_err("mtk-jpeg: write reg %x without %d align\n", reg, align); - return -1; - } - - return 0; -} - -static int mtk_jpeg_decide_format(struct mtk_jpeg_dec_param *param) -{ - param->src_color = (param->sampling_w[0] << 20) | - (param->sampling_h[0] << 16) | - (param->sampling_w[1] << 12) | - (param->sampling_h[1] << 8) | - (param->sampling_w[2] << 4) | - (param->sampling_h[2]); - - param->uv_brz_w = 0; - switch (param->src_color) { - case MTK_JPEG_COLOR_444: - param->uv_brz_w = 1; - param->dst_fourcc = V4L2_PIX_FMT_YUV422M; - break; - case MTK_JPEG_COLOR_422X2: - case MTK_JPEG_COLOR_422: - param->dst_fourcc = V4L2_PIX_FMT_YUV422M; - break; - case MTK_JPEG_COLOR_422V: - case MTK_JPEG_COLOR_422VX2: - param->uv_brz_w = 1; - param->dst_fourcc = V4L2_PIX_FMT_YUV420M; - break; - case MTK_JPEG_COLOR_420: - param->dst_fourcc = V4L2_PIX_FMT_YUV420M; - break; - case MTK_JPEG_COLOR_400: - param->dst_fourcc = V4L2_PIX_FMT_GREY; - break; - default: - param->dst_fourcc = 0; - return -1; - } - - return 0; -} - -static void mtk_jpeg_calc_mcu(struct mtk_jpeg_dec_param *param) -{ - u32 factor_w, factor_h; - u32 i, comp, blk; - - factor_w = 2 + param->sampling_w[0]; - factor_h = 2 + param->sampling_h[0]; - param->mcu_w = (param->pic_w + (1 << factor_w) - 1) >> factor_w; - param->mcu_h = (param->pic_h + (1 << factor_h) - 1) >> factor_h; - param->total_mcu = param->mcu_w * param->mcu_h; - param->unit_num = ((param->pic_w + 7) >> 3) * ((param->pic_h + 7) >> 3); - param->blk_num = 0; - for (i = 0; i < MTK_JPEG_COMP_MAX; i++) { - param->blk_comp[i] = 0; - if (i >= param->comp_num) - continue; - param->blk_comp[i] = param->sampling_w[i] * - param->sampling_h[i]; - param->blk_num += param->blk_comp[i]; - } - - param->membership = 0; - for (i = 0, blk = 0, comp = 0; i < MTK_JPEG_BLOCK_MAX; i++) { - if (i < param->blk_num && comp < param->comp_num) { - u32 tmp; - - tmp = (0x04 + (comp & 0x3)); - param->membership |= tmp << (i * 3); - if (++blk == param->blk_comp[comp]) { - comp++; - blk = 0; - } - } else { - param->membership |= 7 << (i * 3); - } - } -} - -static void mtk_jpeg_calc_dma_group(struct mtk_jpeg_dec_param *param) -{ - u32 factor_mcu = 3; - - if (param->src_color == MTK_JPEG_COLOR_444 && - param->dst_fourcc == V4L2_PIX_FMT_YUV422M) - factor_mcu = 4; - else if (param->src_color == MTK_JPEG_COLOR_422V && - param->dst_fourcc == V4L2_PIX_FMT_YUV420M) - factor_mcu = 4; - else if (param->src_color == MTK_JPEG_COLOR_422X2 && - param->dst_fourcc == V4L2_PIX_FMT_YUV422M) - factor_mcu = 2; - else if (param->src_color == MTK_JPEG_COLOR_400 || - (param->src_color & 0x0FFFF) == 0) - factor_mcu = 4; - - param->dma_mcu = 1 << factor_mcu; - param->dma_group = param->mcu_w / param->dma_mcu; - param->dma_last_mcu = param->mcu_w % param->dma_mcu; - if (param->dma_last_mcu) - param->dma_group++; - else - param->dma_last_mcu = param->dma_mcu; -} - -static int mtk_jpeg_calc_dst_size(struct mtk_jpeg_dec_param *param) -{ - u32 i, padding_w; - u32 ds_row_h[3]; - u32 brz_w[3]; - - brz_w[0] = 0; - brz_w[1] = param->uv_brz_w; - brz_w[2] = brz_w[1]; - - for (i = 0; i < param->comp_num; i++) { - if (brz_w[i] > 3) - return -1; - - padding_w = param->mcu_w * MTK_JPEG_DCTSIZE * - param->sampling_w[i]; - /* output format is 420/422 */ - param->comp_w[i] = padding_w >> brz_w[i]; - param->comp_w[i] = round_up(param->comp_w[i], - MTK_JPEG_DCTSIZE); - param->img_stride[i] = i ? round_up(param->comp_w[i], 16) - : round_up(param->comp_w[i], 32); - ds_row_h[i] = (MTK_JPEG_DCTSIZE * param->sampling_h[i]); - } - param->dec_w = param->img_stride[0]; - param->dec_h = ds_row_h[0] * param->mcu_h; - - for (i = 0; i < MTK_JPEG_COMP_MAX; i++) { - /* They must be equal in frame mode. */ - param->mem_stride[i] = param->img_stride[i]; - param->comp_size[i] = param->mem_stride[i] * ds_row_h[i] * - param->mcu_h; - } - - param->y_size = param->comp_size[0]; - param->uv_size = param->comp_size[1]; - param->dec_size = param->y_size + (param->uv_size << 1); - - return 0; -} - -int mtk_jpeg_dec_fill_param(struct mtk_jpeg_dec_param *param) -{ - if (mtk_jpeg_decide_format(param)) - return -1; - - mtk_jpeg_calc_mcu(param); - mtk_jpeg_calc_dma_group(param); - if (mtk_jpeg_calc_dst_size(param)) - return -2; - - return 0; -} - -u32 mtk_jpeg_dec_get_int_status(void __iomem *base) -{ - u32 ret; - - ret = readl(base + JPGDEC_REG_INTERRUPT_STATUS) & BIT_INQST_MASK_ALLIRQ; - if (ret) - writel(ret, base + JPGDEC_REG_INTERRUPT_STATUS); - - return ret; -} - -u32 mtk_jpeg_dec_enum_result(u32 irq_result) -{ - if (irq_result & BIT_INQST_MASK_EOF) - return MTK_JPEG_DEC_RESULT_EOF_DONE; - if (irq_result & BIT_INQST_MASK_PAUSE) - return MTK_JPEG_DEC_RESULT_PAUSE; - if (irq_result & BIT_INQST_MASK_UNDERFLOW) - return MTK_JPEG_DEC_RESULT_UNDERFLOW; - if (irq_result & BIT_INQST_MASK_OVERFLOW) - return MTK_JPEG_DEC_RESULT_OVERFLOW; - if (irq_result & BIT_INQST_MASK_ERROR_BS) - return MTK_JPEG_DEC_RESULT_ERROR_BS; - - return MTK_JPEG_DEC_RESULT_ERROR_UNKNOWN; -} - -void mtk_jpeg_dec_start(void __iomem *base) -{ - writel(0, base + JPGDEC_REG_TRIG); -} - -static void mtk_jpeg_dec_soft_reset(void __iomem *base) -{ - writel(0x0000FFFF, base + JPGDEC_REG_INTERRUPT_STATUS); - writel(0x00, base + JPGDEC_REG_RESET); - writel(0x01, base + JPGDEC_REG_RESET); -} - -static void mtk_jpeg_dec_hard_reset(void __iomem *base) -{ - writel(0x00, base + JPGDEC_REG_RESET); - writel(0x10, base + JPGDEC_REG_RESET); -} - -void mtk_jpeg_dec_reset(void __iomem *base) -{ - mtk_jpeg_dec_soft_reset(base); - mtk_jpeg_dec_hard_reset(base); -} - -static void mtk_jpeg_dec_set_brz_factor(void __iomem *base, u8 yscale_w, - u8 yscale_h, u8 uvscale_w, u8 uvscale_h) -{ - u32 val; - - val = (uvscale_h << 12) | (uvscale_w << 8) | - (yscale_h << 4) | yscale_w; - writel(val, base + JPGDEC_REG_BRZ_FACTOR); -} - -static void mtk_jpeg_dec_set_dst_bank0(void __iomem *base, u32 addr_y, - u32 addr_u, u32 addr_v) -{ - mtk_jpeg_verify_align(addr_y, 16, JPGDEC_REG_DEST_ADDR0_Y); - writel(addr_y, base + JPGDEC_REG_DEST_ADDR0_Y); - mtk_jpeg_verify_align(addr_u, 16, JPGDEC_REG_DEST_ADDR0_U); - writel(addr_u, base + JPGDEC_REG_DEST_ADDR0_U); - mtk_jpeg_verify_align(addr_v, 16, JPGDEC_REG_DEST_ADDR0_V); - writel(addr_v, base + JPGDEC_REG_DEST_ADDR0_V); -} - -static void mtk_jpeg_dec_set_dst_bank1(void __iomem *base, u32 addr_y, - u32 addr_u, u32 addr_v) -{ - writel(addr_y, base + JPGDEC_REG_DEST_ADDR1_Y); - writel(addr_u, base + JPGDEC_REG_DEST_ADDR1_U); - writel(addr_v, base + JPGDEC_REG_DEST_ADDR1_V); -} - -static void mtk_jpeg_dec_set_mem_stride(void __iomem *base, u32 stride_y, - u32 stride_uv) -{ - writel((stride_y & 0xFFFF), base + JPGDEC_REG_STRIDE_Y); - writel((stride_uv & 0xFFFF), base + JPGDEC_REG_STRIDE_UV); -} - -static void mtk_jpeg_dec_set_img_stride(void __iomem *base, u32 stride_y, - u32 stride_uv) -{ - writel((stride_y & 0xFFFF), base + JPGDEC_REG_IMG_STRIDE_Y); - writel((stride_uv & 0xFFFF), base + JPGDEC_REG_IMG_STRIDE_UV); -} - -static void mtk_jpeg_dec_set_pause_mcu_idx(void __iomem *base, u32 idx) -{ - writel(idx & 0x0003FFFFFF, base + JPGDEC_REG_PAUSE_MCU_NUM); -} - -static void mtk_jpeg_dec_set_dec_mode(void __iomem *base, u32 mode) -{ - writel(mode & 0x03, base + JPGDEC_REG_OPERATION_MODE); -} - -static void mtk_jpeg_dec_set_bs_write_ptr(void __iomem *base, u32 ptr) -{ - mtk_jpeg_verify_align(ptr, 16, JPGDEC_REG_FILE_BRP); - writel(ptr, base + JPGDEC_REG_FILE_BRP); -} - -static void mtk_jpeg_dec_set_bs_info(void __iomem *base, u32 addr, u32 size) -{ - mtk_jpeg_verify_align(addr, 16, JPGDEC_REG_FILE_ADDR); - mtk_jpeg_verify_align(size, 128, JPGDEC_REG_FILE_TOTAL_SIZE); - writel(addr, base + JPGDEC_REG_FILE_ADDR); - writel(size, base + JPGDEC_REG_FILE_TOTAL_SIZE); -} - -static void mtk_jpeg_dec_set_comp_id(void __iomem *base, u32 id_y, u32 id_u, - u32 id_v) -{ - u32 val; - - val = ((id_y & 0x00FF) << 24) | ((id_u & 0x00FF) << 16) | - ((id_v & 0x00FF) << 8); - writel(val, base + JPGDEC_REG_COMP_ID); -} - -static void mtk_jpeg_dec_set_total_mcu(void __iomem *base, u32 num) -{ - writel(num - 1, base + JPGDEC_REG_TOTAL_MCU_NUM); -} - -static void mtk_jpeg_dec_set_comp0_du(void __iomem *base, u32 num) -{ - writel(num - 1, base + JPGDEC_REG_COMP0_DATA_UNIT_NUM); -} - -static void mtk_jpeg_dec_set_du_membership(void __iomem *base, u32 member, - u32 gmc, u32 isgray) -{ - if (isgray) - member = 0x3FFFFFFC; - member |= (isgray << 31) | (gmc << 30); - writel(member, base + JPGDEC_REG_DU_CTRL); -} - -static void mtk_jpeg_dec_set_q_table(void __iomem *base, u32 id0, u32 id1, - u32 id2) -{ - u32 val; - - val = ((id0 & 0x0f) << 8) | ((id1 & 0x0f) << 4) | ((id2 & 0x0f) << 0); - writel(val, base + JPGDEC_REG_QT_ID); -} - -static void mtk_jpeg_dec_set_dma_group(void __iomem *base, u32 mcu_group, - u32 group_num, u32 last_mcu) -{ - u32 val; - - val = (((mcu_group - 1) & 0x00FF) << 16) | - (((group_num - 1) & 0x007F) << 8) | - ((last_mcu - 1) & 0x00FF); - writel(val, base + JPGDEC_REG_WDMA_CTRL); -} - -static void mtk_jpeg_dec_set_sampling_factor(void __iomem *base, u32 comp_num, - u32 y_w, u32 y_h, u32 u_w, - u32 u_h, u32 v_w, u32 v_h) -{ - u32 val; - u32 y_wh = (MTK_JPEG_DUNUM_MASK(y_w) << 2) | MTK_JPEG_DUNUM_MASK(y_h); - u32 u_wh = (MTK_JPEG_DUNUM_MASK(u_w) << 2) | MTK_JPEG_DUNUM_MASK(u_h); - u32 v_wh = (MTK_JPEG_DUNUM_MASK(v_w) << 2) | MTK_JPEG_DUNUM_MASK(v_h); - - if (comp_num == 1) - val = 0; - else - val = (y_wh << 8) | (u_wh << 4) | v_wh; - writel(val, base + JPGDEC_REG_DU_NUM); -} - -void mtk_jpeg_dec_set_config(void __iomem *base, - struct mtk_jpeg_dec_param *config, - struct mtk_jpeg_bs *bs, - struct mtk_jpeg_fb *fb) -{ - mtk_jpeg_dec_set_brz_factor(base, 0, 0, config->uv_brz_w, 0); - mtk_jpeg_dec_set_dec_mode(base, 0); - mtk_jpeg_dec_set_comp0_du(base, config->unit_num); - mtk_jpeg_dec_set_total_mcu(base, config->total_mcu); - mtk_jpeg_dec_set_bs_info(base, bs->str_addr, bs->size); - mtk_jpeg_dec_set_bs_write_ptr(base, bs->end_addr); - mtk_jpeg_dec_set_du_membership(base, config->membership, 1, - (config->comp_num == 1) ? 1 : 0); - mtk_jpeg_dec_set_comp_id(base, config->comp_id[0], config->comp_id[1], - config->comp_id[2]); - mtk_jpeg_dec_set_q_table(base, config->qtbl_num[0], - config->qtbl_num[1], config->qtbl_num[2]); - mtk_jpeg_dec_set_sampling_factor(base, config->comp_num, - config->sampling_w[0], - config->sampling_h[0], - config->sampling_w[1], - config->sampling_h[1], - config->sampling_w[2], - config->sampling_h[2]); - mtk_jpeg_dec_set_mem_stride(base, config->mem_stride[0], - config->mem_stride[1]); - mtk_jpeg_dec_set_img_stride(base, config->img_stride[0], - config->img_stride[1]); - mtk_jpeg_dec_set_dst_bank0(base, fb->plane_addr[0], - fb->plane_addr[1], fb->plane_addr[2]); - mtk_jpeg_dec_set_dst_bank1(base, 0, 0, 0); - mtk_jpeg_dec_set_dma_group(base, config->dma_mcu, config->dma_group, - config->dma_last_mcu); - mtk_jpeg_dec_set_pause_mcu_idx(base, config->total_mcu); -} diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h deleted file mode 100644 index fa0d45fd7c34..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h +++ /dev/null @@ -1,79 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - * Xia Jiang - */ - -#ifndef _MTK_JPEG_DEC_HW_H -#define _MTK_JPEG_DEC_HW_H - -#include - -#include "mtk_jpeg_core.h" -#include "mtk_jpeg_dec_reg.h" - -enum { - MTK_JPEG_DEC_RESULT_EOF_DONE = 0, - MTK_JPEG_DEC_RESULT_PAUSE = 1, - MTK_JPEG_DEC_RESULT_UNDERFLOW = 2, - MTK_JPEG_DEC_RESULT_OVERFLOW = 3, - MTK_JPEG_DEC_RESULT_ERROR_BS = 4, - MTK_JPEG_DEC_RESULT_ERROR_UNKNOWN = 6 -}; - -struct mtk_jpeg_dec_param { - u32 pic_w; - u32 pic_h; - u32 dec_w; - u32 dec_h; - u32 src_color; - u32 dst_fourcc; - u32 mcu_w; - u32 mcu_h; - u32 total_mcu; - u32 unit_num; - u32 comp_num; - u32 comp_id[MTK_JPEG_COMP_MAX]; - u32 sampling_w[MTK_JPEG_COMP_MAX]; - u32 sampling_h[MTK_JPEG_COMP_MAX]; - u32 qtbl_num[MTK_JPEG_COMP_MAX]; - u32 blk_num; - u32 blk_comp[MTK_JPEG_COMP_MAX]; - u32 membership; - u32 dma_mcu; - u32 dma_group; - u32 dma_last_mcu; - u32 img_stride[MTK_JPEG_COMP_MAX]; - u32 mem_stride[MTK_JPEG_COMP_MAX]; - u32 comp_w[MTK_JPEG_COMP_MAX]; - u32 comp_size[MTK_JPEG_COMP_MAX]; - u32 y_size; - u32 uv_size; - u32 dec_size; - u8 uv_brz_w; -}; - -struct mtk_jpeg_bs { - dma_addr_t str_addr; - dma_addr_t end_addr; - size_t size; -}; - -struct mtk_jpeg_fb { - dma_addr_t plane_addr[MTK_JPEG_COMP_MAX]; - size_t size; -}; - -int mtk_jpeg_dec_fill_param(struct mtk_jpeg_dec_param *param); -u32 mtk_jpeg_dec_get_int_status(void __iomem *dec_reg_base); -u32 mtk_jpeg_dec_enum_result(u32 irq_result); -void mtk_jpeg_dec_set_config(void __iomem *base, - struct mtk_jpeg_dec_param *config, - struct mtk_jpeg_bs *bs, - struct mtk_jpeg_fb *fb); -void mtk_jpeg_dec_reset(void __iomem *dec_reg_base); -void mtk_jpeg_dec_start(void __iomem *dec_reg_base); - -#endif /* _MTK_JPEG_HW_H */ diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.c deleted file mode 100644 index b95c45791c29..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.c +++ /dev/null @@ -1,152 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - */ - -#include -#include - -#include "mtk_jpeg_dec_parse.h" - -#define TEM 0x01 -#define SOF0 0xc0 -#define RST 0xd0 -#define SOI 0xd8 -#define EOI 0xd9 - -struct mtk_jpeg_stream { - u8 *addr; - u32 size; - u32 curr; -}; - -static int read_byte(struct mtk_jpeg_stream *stream) -{ - if (stream->curr >= stream->size) - return -1; - return stream->addr[stream->curr++]; -} - -static int read_word_be(struct mtk_jpeg_stream *stream, u32 *word) -{ - u32 temp; - int byte; - - byte = read_byte(stream); - if (byte == -1) - return -1; - temp = byte << 8; - byte = read_byte(stream); - if (byte == -1) - return -1; - *word = (u32)byte | temp; - - return 0; -} - -static void read_skip(struct mtk_jpeg_stream *stream, long len) -{ - if (len <= 0) - return; - while (len--) - read_byte(stream); -} - -static bool mtk_jpeg_do_parse(struct mtk_jpeg_dec_param *param, u8 *src_addr_va, - u32 src_size) -{ - bool notfound = true; - struct mtk_jpeg_stream stream; - - stream.addr = src_addr_va; - stream.size = src_size; - stream.curr = 0; - - while (notfound) { - int i, length, byte; - u32 word; - - byte = read_byte(&stream); - if (byte == -1) - return false; - if (byte != 0xff) - continue; - do - byte = read_byte(&stream); - while (byte == 0xff); - if (byte == -1) - return false; - if (byte == 0) - continue; - - length = 0; - switch (byte) { - case SOF0: - /* length */ - if (read_word_be(&stream, &word)) - break; - - /* precision */ - if (read_byte(&stream) == -1) - break; - - if (read_word_be(&stream, &word)) - break; - param->pic_h = word; - - if (read_word_be(&stream, &word)) - break; - param->pic_w = word; - - param->comp_num = read_byte(&stream); - if (param->comp_num != 1 && param->comp_num != 3) - break; - - for (i = 0; i < param->comp_num; i++) { - param->comp_id[i] = read_byte(&stream); - if (param->comp_id[i] == -1) - break; - - /* sampling */ - byte = read_byte(&stream); - if (byte == -1) - break; - param->sampling_w[i] = (byte >> 4) & 0x0F; - param->sampling_h[i] = byte & 0x0F; - - param->qtbl_num[i] = read_byte(&stream); - if (param->qtbl_num[i] == -1) - break; - } - - notfound = !(i == param->comp_num); - break; - case RST ... RST + 7: - case SOI: - case EOI: - case TEM: - break; - default: - if (read_word_be(&stream, &word)) - break; - length = (long)word - 2; - read_skip(&stream, length); - break; - } - } - - return !notfound; -} - -bool mtk_jpeg_parse(struct mtk_jpeg_dec_param *param, u8 *src_addr_va, - u32 src_size) -{ - if (!mtk_jpeg_do_parse(param, src_addr_va, src_size)) - return false; - if (mtk_jpeg_dec_fill_param(param)) - return false; - - return true; -} diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.h deleted file mode 100644 index 2918f15811f8..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_parse.h +++ /dev/null @@ -1,17 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - */ - -#ifndef _MTK_JPEG_PARSE_H -#define _MTK_JPEG_PARSE_H - -#include "mtk_jpeg_dec_hw.h" - -bool mtk_jpeg_parse(struct mtk_jpeg_dec_param *param, u8 *src_addr_va, - u32 src_size); - -#endif /* _MTK_JPEG_PARSE_H */ - diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_reg.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_reg.h deleted file mode 100644 index 21ec8f96797f..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_reg.h +++ /dev/null @@ -1,49 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2016 MediaTek Inc. - * Author: Ming Hsiu Tsai - * Rick Chang - */ - -#ifndef _MTK_JPEG_REG_H -#define _MTK_JPEG_REG_H - -#define MTK_JPEG_BLOCK_MAX 10 -#define MTK_JPEG_DCTSIZE 8 - -#define BIT_INQST_MASK_ERROR_BS 0x20 -#define BIT_INQST_MASK_PAUSE 0x10 -#define BIT_INQST_MASK_OVERFLOW 0x04 -#define BIT_INQST_MASK_UNDERFLOW 0x02 -#define BIT_INQST_MASK_EOF 0x01 -#define BIT_INQST_MASK_ALLIRQ 0x37 - -#define JPGDEC_REG_RESET 0x0090 -#define JPGDEC_REG_BRZ_FACTOR 0x00f8 -#define JPGDEC_REG_DU_NUM 0x00fc -#define JPGDEC_REG_DEST_ADDR0_Y 0x0140 -#define JPGDEC_REG_DEST_ADDR0_U 0x0144 -#define JPGDEC_REG_DEST_ADDR0_V 0x0148 -#define JPGDEC_REG_DEST_ADDR1_Y 0x014c -#define JPGDEC_REG_DEST_ADDR1_U 0x0150 -#define JPGDEC_REG_DEST_ADDR1_V 0x0154 -#define JPGDEC_REG_STRIDE_Y 0x0158 -#define JPGDEC_REG_STRIDE_UV 0x015c -#define JPGDEC_REG_IMG_STRIDE_Y 0x0160 -#define JPGDEC_REG_IMG_STRIDE_UV 0x0164 -#define JPGDEC_REG_WDMA_CTRL 0x016c -#define JPGDEC_REG_PAUSE_MCU_NUM 0x0170 -#define JPGDEC_REG_OPERATION_MODE 0x017c -#define JPGDEC_REG_FILE_ADDR 0x0200 -#define JPGDEC_REG_COMP_ID 0x020c -#define JPGDEC_REG_TOTAL_MCU_NUM 0x0210 -#define JPGDEC_REG_COMP0_DATA_UNIT_NUM 0x0224 -#define JPGDEC_REG_DU_CTRL 0x023c -#define JPGDEC_REG_TRIG 0x0240 -#define JPGDEC_REG_FILE_BRP 0x0248 -#define JPGDEC_REG_FILE_TOTAL_SIZE 0x024c -#define JPGDEC_REG_QT_ID 0x0270 -#define JPGDEC_REG_INTERRUPT_STATUS 0x0274 -#define JPGDEC_REG_STATUS 0x0278 - -#endif /* _MTK_JPEG_REG_H */ diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c deleted file mode 100644 index 1cf037bf72dd..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c +++ /dev/null @@ -1,154 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (c) 2019 MediaTek Inc. - * Author: Xia Jiang - * - */ - -#include -#include -#include -#include - -#include "mtk_jpeg_enc_hw.h" - -static const struct mtk_jpeg_enc_qlt mtk_jpeg_enc_quality[] = { - {.quality_param = 34, .hardware_value = JPEG_ENC_QUALITY_Q34}, - {.quality_param = 39, .hardware_value = JPEG_ENC_QUALITY_Q39}, - {.quality_param = 48, .hardware_value = JPEG_ENC_QUALITY_Q48}, - {.quality_param = 60, .hardware_value = JPEG_ENC_QUALITY_Q60}, - {.quality_param = 64, .hardware_value = JPEG_ENC_QUALITY_Q64}, - {.quality_param = 68, .hardware_value = JPEG_ENC_QUALITY_Q68}, - {.quality_param = 74, .hardware_value = JPEG_ENC_QUALITY_Q74}, - {.quality_param = 80, .hardware_value = JPEG_ENC_QUALITY_Q80}, - {.quality_param = 82, .hardware_value = JPEG_ENC_QUALITY_Q82}, - {.quality_param = 84, .hardware_value = JPEG_ENC_QUALITY_Q84}, - {.quality_param = 87, .hardware_value = JPEG_ENC_QUALITY_Q87}, - {.quality_param = 90, .hardware_value = JPEG_ENC_QUALITY_Q90}, - {.quality_param = 92, .hardware_value = JPEG_ENC_QUALITY_Q92}, - {.quality_param = 95, .hardware_value = JPEG_ENC_QUALITY_Q95}, - {.quality_param = 97, .hardware_value = JPEG_ENC_QUALITY_Q97}, -}; - -void mtk_jpeg_enc_reset(void __iomem *base) -{ - writel(0, base + JPEG_ENC_RSTB); - writel(JPEG_ENC_RESET_BIT, base + JPEG_ENC_RSTB); - writel(0, base + JPEG_ENC_CODEC_SEL); -} - -u32 mtk_jpeg_enc_get_file_size(void __iomem *base) -{ - return readl(base + JPEG_ENC_DMA_ADDR0) - - readl(base + JPEG_ENC_DST_ADDR0); -} - -void mtk_jpeg_enc_start(void __iomem *base) -{ - u32 value; - - value = readl(base + JPEG_ENC_CTRL); - value |= JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT; - writel(value, base + JPEG_ENC_CTRL); -} - -void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, - struct vb2_buffer *src_buf) -{ - int i; - dma_addr_t dma_addr; - - for (i = 0; i < src_buf->num_planes; i++) { - dma_addr = vb2_dma_contig_plane_dma_addr(src_buf, i) + - src_buf->planes[i].data_offset; - if (!i) - writel(dma_addr, base + JPEG_ENC_SRC_LUMA_ADDR); - else - writel(dma_addr, base + JPEG_ENC_SRC_CHROMA_ADDR); - } -} - -void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, - struct vb2_buffer *dst_buf) -{ - dma_addr_t dma_addr; - size_t size; - u32 dma_addr_offset; - u32 dma_addr_offsetmask; - - dma_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0); - dma_addr_offset = ctx->enable_exif ? MTK_JPEG_MAX_EXIF_SIZE : 0; - dma_addr_offsetmask = dma_addr & JPEG_ENC_DST_ADDR_OFFSET_MASK; - size = vb2_plane_size(dst_buf, 0); - - writel(dma_addr_offset & ~0xf, base + JPEG_ENC_OFFSET_ADDR); - writel(dma_addr_offsetmask & 0xf, base + JPEG_ENC_BYTE_OFFSET_MASK); - writel(dma_addr & ~0xf, base + JPEG_ENC_DST_ADDR0); - writel((dma_addr + size) & ~0xf, base + JPEG_ENC_STALL_ADDR0); -} - -void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base) -{ - u32 value; - u32 width = ctx->out_q.enc_crop_rect.width; - u32 height = ctx->out_q.enc_crop_rect.height; - u32 enc_format = ctx->out_q.fmt->fourcc; - u32 bytesperline = ctx->out_q.pix_mp.plane_fmt[0].bytesperline; - u32 blk_num; - u32 img_stride; - u32 mem_stride; - u32 i, enc_quality; - - value = width << 16 | height; - writel(value, base + JPEG_ENC_IMG_SIZE); - - if (enc_format == V4L2_PIX_FMT_NV12M || - enc_format == V4L2_PIX_FMT_NV21M) - /* - * Total 8 x 8 block number of luma and chroma. - * The number of blocks is counted from 0. - */ - blk_num = DIV_ROUND_UP(width, 16) * - DIV_ROUND_UP(height, 16) * 6 - 1; - else - blk_num = DIV_ROUND_UP(width, 16) * - DIV_ROUND_UP(height, 8) * 4 - 1; - writel(blk_num, base + JPEG_ENC_BLK_NUM); - - if (enc_format == V4L2_PIX_FMT_NV12M || - enc_format == V4L2_PIX_FMT_NV21M) { - /* 4:2:0 */ - img_stride = round_up(width, 16); - mem_stride = bytesperline; - } else { - /* 4:2:2 */ - img_stride = round_up(width * 2, 32); - mem_stride = img_stride; - } - writel(img_stride, base + JPEG_ENC_IMG_STRIDE); - writel(mem_stride, base + JPEG_ENC_STRIDE); - - enc_quality = mtk_jpeg_enc_quality[0].hardware_value; - for (i = 0; i < ARRAY_SIZE(mtk_jpeg_enc_quality); i++) { - if (ctx->enc_quality <= mtk_jpeg_enc_quality[i].quality_param) { - enc_quality = mtk_jpeg_enc_quality[i].hardware_value; - break; - } - } - writel(enc_quality, base + JPEG_ENC_QUALITY); - - value = readl(base + JPEG_ENC_CTRL); - value &= ~JPEG_ENC_CTRL_YUV_FORMAT_MASK; - value |= (ctx->out_q.fmt->hw_format & 3) << 3; - if (ctx->enable_exif) - value |= JPEG_ENC_CTRL_FILE_FORMAT_BIT; - else - value &= ~JPEG_ENC_CTRL_FILE_FORMAT_BIT; - if (ctx->restart_interval) - value |= JPEG_ENC_CTRL_RESTART_EN_BIT; - else - value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT; - writel(value, base + JPEG_ENC_CTRL); - - writel(ctx->restart_interval, base + JPEG_ENC_RST_MCU_NUM); -} diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h deleted file mode 100644 index 61c60e4e58ea..000000000000 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h +++ /dev/null @@ -1,91 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (c) 2019 MediaTek Inc. - * Author: Xia Jiang - * - */ - -#ifndef _MTK_JPEG_ENC_HW_H -#define _MTK_JPEG_ENC_HW_H - -#include - -#include "mtk_jpeg_core.h" - -#define JPEG_ENC_INT_STATUS_DONE BIT(0) -#define JPEG_ENC_INT_STATUS_MASK_ALLIRQ 0x13 - -#define JPEG_ENC_DST_ADDR_OFFSET_MASK GENMASK(3, 0) - -#define JPEG_ENC_CTRL_YUV_FORMAT_MASK 0x18 -#define JPEG_ENC_CTRL_RESTART_EN_BIT BIT(10) -#define JPEG_ENC_CTRL_FILE_FORMAT_BIT BIT(5) -#define JPEG_ENC_CTRL_INT_EN_BIT BIT(2) -#define JPEG_ENC_CTRL_ENABLE_BIT BIT(0) -#define JPEG_ENC_RESET_BIT BIT(0) - -#define JPEG_ENC_YUV_FORMAT_YUYV 0 -#define JPEG_ENC_YUV_FORMAT_YVYU 1 -#define JPEG_ENC_YUV_FORMAT_NV12 2 -#define JEPG_ENC_YUV_FORMAT_NV21 3 - -#define JPEG_ENC_QUALITY_Q60 0x0 -#define JPEG_ENC_QUALITY_Q80 0x1 -#define JPEG_ENC_QUALITY_Q90 0x2 -#define JPEG_ENC_QUALITY_Q95 0x3 -#define JPEG_ENC_QUALITY_Q39 0x4 -#define JPEG_ENC_QUALITY_Q68 0x5 -#define JPEG_ENC_QUALITY_Q84 0x6 -#define JPEG_ENC_QUALITY_Q92 0x7 -#define JPEG_ENC_QUALITY_Q48 0x8 -#define JPEG_ENC_QUALITY_Q74 0xa -#define JPEG_ENC_QUALITY_Q87 0xb -#define JPEG_ENC_QUALITY_Q34 0xc -#define JPEG_ENC_QUALITY_Q64 0xe -#define JPEG_ENC_QUALITY_Q82 0xf -#define JPEG_ENC_QUALITY_Q97 0x10 - -#define JPEG_ENC_RSTB 0x100 -#define JPEG_ENC_CTRL 0x104 -#define JPEG_ENC_QUALITY 0x108 -#define JPEG_ENC_BLK_NUM 0x10C -#define JPEG_ENC_BLK_CNT 0x110 -#define JPEG_ENC_INT_STS 0x11c -#define JPEG_ENC_DST_ADDR0 0x120 -#define JPEG_ENC_DMA_ADDR0 0x124 -#define JPEG_ENC_STALL_ADDR0 0x128 -#define JPEG_ENC_OFFSET_ADDR 0x138 -#define JPEG_ENC_RST_MCU_NUM 0x150 -#define JPEG_ENC_IMG_SIZE 0x154 -#define JPEG_ENC_DEBUG_INFO0 0x160 -#define JPEG_ENC_DEBUG_INFO1 0x164 -#define JPEG_ENC_TOTAL_CYCLE 0x168 -#define JPEG_ENC_BYTE_OFFSET_MASK 0x16c -#define JPEG_ENC_SRC_LUMA_ADDR 0x170 -#define JPEG_ENC_SRC_CHROMA_ADDR 0x174 -#define JPEG_ENC_STRIDE 0x178 -#define JPEG_ENC_IMG_STRIDE 0x17c -#define JPEG_ENC_DCM_CTRL 0x300 -#define JPEG_ENC_CODEC_SEL 0x314 -#define JPEG_ENC_ULTRA_THRES 0x318 - -/** - * struct mtk_jpeg_enc_qlt - JPEG encoder quality data - * @quality_param: quality value - * @hardware_value: hardware value of quality - */ -struct mtk_jpeg_enc_qlt { - u8 quality_param; - u8 hardware_value; -}; - -void mtk_jpeg_enc_reset(void __iomem *base); -u32 mtk_jpeg_enc_get_file_size(void __iomem *base); -void mtk_jpeg_enc_start(void __iomem *enc_reg_base); -void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, - struct vb2_buffer *src_buf); -void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, - struct vb2_buffer *dst_buf); -void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base); - -#endif /* _MTK_JPEG_ENC_HW_H */ -- cgit v1.2.3