From: Nicolas Dufresne <nicolas.dufresne@collabora.com>
To: Paul Kocialkowski <paulk@sys-base.io>,
devicetree@vger.kernel.org, imx@lists.linux.dev,
linux-arm-kernel@lists.infradead.org,
linux-kernel@vger.kernel.org, linux-media@vger.kernel.org
Cc: Rob Herring <robh@kernel.org>,
Krzysztof Kozlowski <krzk+dt@kernel.org>,
Conor Dooley <conor+dt@kernel.org>,
Shawn Guo <shawnguo@kernel.org>,
Sascha Hauer <s.hauer@pengutronix.de>,
Pengutronix Kernel Team <kernel@pengutronix.de>,
Benjamin Gaignard <benjamin.gaignard@collabora.com>,
Philipp Zabel <p.zabel@pengutronix.de>,
Mauro Carvalho Chehab <mchehab@kernel.org>,
Hans Verkuil <hverkuil@kernel.org>,
Marco Felsch <m.felsch@pengutronix.de>,
Michael Tretter <m.tretter@pengutronix.de>
Subject: Re: [PATCH 12/14] media: verisilicon: Add support for the VC8000E H.264 encoder
Date: Tue, 17 Nov 2026 17:00:14 -0500 [thread overview]
Message-ID: <206d0fb68342892f1e007ff7299dd07edc65e80a.camel@collabora.com> (raw)
In-Reply-To: <20260522101653.2565125-13-paulk@sys-base.io>
[-- Attachment #1: Type: text/plain, Size: 96930 bytes --]
Hi,
warning: partial review.
Le vendredi 22 mai 2026 à 12:16 +0200, Paul Kocialkowski a écrit :
> This introduces support for the Hantro VC8000E H.264 encoder,
> a stateless hardware encoder from Verisilicon.
>
> This driver is the first user of the V4L2 H.264 stateless encoding
> core and uAPI.
>
> The hardware needs to be programmed in a sequential way (registers
> written in ascending offset order) so the registers are programmed
> in a memory buffer first and copied in order at the end.
> They are described as packed structured for convenience and should
> also contain all required definitions for HEVC and JPEG support.
>
> Only a single reference frame is currently supported, even though
> the registers seems to indicate that two could be supported.
> More research and investigation is needed to operate two.
>
> The lambda tables are currently hardcoded to generally reasonable
> values but could be recalculated for each target QP to give more
> accurate results.
>
> Most other features of the encoder are supported, except ROI and
> intra areas support which are currently disabled.
>
> Signed-off-by: Paul Kocialkowski <paulk@sys-base.io>
> ---
> drivers/media/platform/verisilicon/Kconfig | 1 +
> drivers/media/platform/verisilicon/Makefile | 2 +
> drivers/media/platform/verisilicon/hantro.h | 14 +
> .../media/platform/verisilicon/hantro_drv.c | 152 +-
> .../media/platform/verisilicon/hantro_h264.c | 6 +-
> .../media/platform/verisilicon/hantro_hw.h | 27 +
> .../media/platform/verisilicon/hantro_v4l2.c | 6 +
> .../platform/verisilicon/hantro_vc8000e.c | 68 +
> .../verisilicon/hantro_vc8000e_h264_enc.c | 883 +++++++
> .../verisilicon/hantro_vc8000e_regs.h | 2129 +++++++++++++++++
> 10 files changed, 3279 insertions(+), 9 deletions(-)
> create mode 100644 drivers/media/platform/verisilicon/hantro_vc8000e.c
> create mode 100644 drivers/media/platform/verisilicon/hantro_vc8000e_h264_enc.c
> create mode 100644 drivers/media/platform/verisilicon/hantro_vc8000e_regs.h
>
> diff --git a/drivers/media/platform/verisilicon/Kconfig b/drivers/media/platform/verisilicon/Kconfig
> index 3272a24db71d..ae186a848e24 100644
> --- a/drivers/media/platform/verisilicon/Kconfig
> +++ b/drivers/media/platform/verisilicon/Kconfig
> @@ -12,6 +12,7 @@ config VIDEO_HANTRO
> select VIDEOBUF2_VMALLOC
> select V4L2_MEM2MEM_DEV
> select V4L2_H264
> + select V4L2_H264_ENC
> select V4L2_JPEG_HELPER
> select V4L2_VP9
> help
> diff --git a/drivers/media/platform/verisilicon/Makefile b/drivers/media/platform/verisilicon/Makefile
> index f6f019d04ff0..caa32de29ab7 100644
> --- a/drivers/media/platform/verisilicon/Makefile
> +++ b/drivers/media/platform/verisilicon/Makefile
> @@ -7,6 +7,8 @@ hantro-vpu-y += \
> hantro_v4l2.o \
> hantro_postproc.o \
> hantro_h1_jpeg_enc.o \
> + hantro_vc8000e.o \
> + hantro_vc8000e_h264_enc.o \
> hantro_g1.o \
> hantro_g1_h264_dec.o \
> hantro_g1_mpeg2_dec.o \
> diff --git a/drivers/media/platform/verisilicon/hantro.h b/drivers/media/platform/verisilicon/hantro.h
> index badd0b13988c..b21c16dd6c1b 100644
> --- a/drivers/media/platform/verisilicon/hantro.h
> +++ b/drivers/media/platform/verisilicon/hantro.h
> @@ -32,6 +32,7 @@ struct hantro_codec_ops;
> struct hantro_postproc_ops;
>
> #define HANTRO_JPEG_ENCODER BIT(0)
> +#define HANTRO_H264_ENCODER BIT(1)
> #define HANTRO_ENCODERS 0x0000ffff
> #define HANTRO_MPEG2_DECODER BIT(16)
> #define HANTRO_VP8_DECODER BIT(17)
> @@ -107,6 +108,7 @@ struct hantro_variant {
> * enum hantro_codec_mode - codec operating mode.
> * @HANTRO_MODE_NONE: No operating mode. Used for RAW video formats.
> * @HANTRO_MODE_JPEG_ENC: JPEG encoder.
> + * @HANTRO_MODE_H264_ENC: H264 encoder.
> * @HANTRO_MODE_H264_DEC: H264 decoder.
> * @HANTRO_MODE_MPEG2_DEC: MPEG-2 decoder.
> * @HANTRO_MODE_VP8_DEC: VP8 decoder.
> @@ -117,6 +119,7 @@ struct hantro_variant {
> enum hantro_codec_mode {
> HANTRO_MODE_NONE = -1,
> HANTRO_MODE_JPEG_ENC,
> + HANTRO_MODE_H264_ENC,
> HANTRO_MODE_H264_DEC,
> HANTRO_MODE_MPEG2_DEC,
> HANTRO_MODE_VP8_DEC,
> @@ -272,6 +275,7 @@ struct hantro_ctx {
> /* Specific for particular codec modes. */
> union {
> struct hantro_h264_dec_hw_ctx h264_dec;
> + struct hantro_h264_enc_hw_ctx h264_enc;
> struct hantro_mpeg2_dec_hw_ctx mpeg2_dec;
> struct hantro_vp8_dec_hw_ctx vp8_dec;
> struct hantro_hevc_dec_hw_ctx hevc_dec;
> @@ -466,6 +470,16 @@ static __always_inline void hantro_reg_write_relaxed(struct hantro_dev *vpu,
> vdpu_write_relaxed(vpu, vdpu_read_mask(vpu, reg, val), reg->base);
> }
>
> +static __always_inline void hantro_io_copy(void __iomem *dst, void *src,
> + size_t size)
> +{
> +#ifdef CONFIG_ARM64
> + __iowrite32_copy(dst, src, size / 4);
> +#else
> + memcpy_toio(dst, src, size);
> +#endif
> +}
> +
> void *hantro_get_ctrl(struct hantro_ctx *ctx, u32 id);
> dma_addr_t hantro_get_ref(struct hantro_ctx *ctx, u64 ts);
>
> diff --git a/drivers/media/platform/verisilicon/hantro_drv.c b/drivers/media/platform/verisilicon/hantro_drv.c
> index d798ba361b25..2de27f0a2be0 100644
> --- a/drivers/media/platform/verisilicon/hantro_drv.c
> +++ b/drivers/media/platform/verisilicon/hantro_drv.c
> @@ -420,6 +420,8 @@ static const struct v4l2_ctrl_ops hantro_av1_ctrl_ops = {
> V4L2_JPEG_ACTIVE_MARKER_DHT)
>
> static const struct hantro_ctrl controls[] = {
> + /* JPEG Encoder */
> +
> {
> .codec = HANTRO_JPEG_ENCODER,
> .cfg = {
> @@ -446,7 +448,127 @@ static const struct hantro_ctrl controls[] = {
> */
> .flags = V4L2_CTRL_FLAG_READ_ONLY,
> },
> + },
> +
> + /* H.264 Encoder */
> +
> + {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_STATELESS_H264_ENCODE_PARAMS,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_STATELESS_H264_SPS,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_STATELESS_H264_PPS,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_STATELESS_H264_START_CODE,
> + .min = V4L2_STATELESS_H264_START_CODE_NONE,
> + .max = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
> + .def = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_AU_DELIMITER,
> + .step = 1,
> + .min = 0,
> + .max = 1,
> + .def = 0,
Any rational not to always insert AUD ?
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR,
> + .step = 1,
> + .min = 0,
> + .max = 1,
> + .def = 0,
Same.
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE,
> + .step = 1,
> + .min = 0,
> + .max = 1,
> + .def = 0,
Same, why not having some default? Of course VBR RC is more common default, but
this disable RC completely?
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_H264_MIN_QP,
> + .step = 1,
> + .min = 0,
> + .max = 51,
> + .def = 0,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_H264_MAX_QP,
> + .step = 1,
> + .min = 0,
> + .max = 51,
> + .def = 51,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
> + .step = 1,
> + .min = 0,
> + .max = 51,
> + .def = 24,
> + },
> }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP,
> + .step = 1,
> + .min = 0,
> + .max = 51,
> + .def = 28,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
> + .min = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
> + .max = V4L2_MPEG_VIDEO_BITRATE_MODE_CQ,
> + .def = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY,
> + .step = 1,
> + .min = 0,
> + .max = 100,
> + .def = 80,
> + },
> + }, {
> + .codec = HANTRO_H264_ENCODER,
> + .cfg = {
> + .id = V4L2_CID_MPEG_VIDEO_BITRATE,
> + .step = 1,
> + .min = 1000,
> + .max = 96000000,
> + .def = 2000000,
> + },
> + },
> +
> + /* MPEG-2 Decoder */
> +
> + {
> .codec = HANTRO_MPEG2_DECODER,
> .cfg = {
> .id = V4L2_CID_STATELESS_MPEG2_SEQUENCE,
> @@ -461,7 +583,11 @@ static const struct hantro_ctrl controls[] = {
> .cfg = {
> .id = V4L2_CID_STATELESS_MPEG2_QUANTISATION,
> },
> - }, {
> + },
> +
> + /* VP8 Decoder */
> +
> + {
> .codec = HANTRO_VP8_DECODER,
> .cfg = {
> .id = V4L2_CID_STATELESS_VP8_FRAME,
> @@ -471,7 +597,11 @@ static const struct hantro_ctrl controls[] = {
> .cfg = {
> .id = V4L2_CID_STATELESS_H264_DECODE_PARAMS,
> },
> - }, {
> + },
> +
> + /* H.264 Decoder */
> +
> + {
> .codec = HANTRO_H264_DECODER,
> .cfg = {
> .id = V4L2_CID_STATELESS_H264_SPS,
> @@ -513,7 +643,11 @@ static const struct hantro_ctrl controls[] = {
> BIT(V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED),
> .def = V4L2_MPEG_VIDEO_H264_PROFILE_MAIN,
> }
> - }, {
> + },
> +
> + /* HEVC Decoder */
> +
> + {
> .codec = HANTRO_HEVC_DECODER,
> .cfg = {
> .id = V4L2_CID_STATELESS_HEVC_DECODE_MODE,
> @@ -565,7 +699,11 @@ static const struct hantro_ctrl controls[] = {
> .cfg = {
> .id = V4L2_CID_STATELESS_HEVC_SCALING_MATRIX,
> },
> - }, {
> + },
> +
> + /* VP9 Decoder */
> +
> + {
> .codec = HANTRO_VP9_DECODER,
> .cfg = {
> .id = V4L2_CID_STATELESS_VP9_FRAME,
> @@ -576,7 +714,11 @@ static const struct hantro_ctrl controls[] = {
> .cfg = {
> .id = V4L2_CID_STATELESS_VP9_COMPRESSED_HDR,
> },
> - }, {
> + },
> +
> + /* AV1 Decoder */
> +
> + {
> .codec = HANTRO_AV1_DECODER,
> .cfg = {
> .id = V4L2_CID_STATELESS_AV1_FRAME,
> diff --git a/drivers/media/platform/verisilicon/hantro_h264.c b/drivers/media/platform/verisilicon/hantro_h264.c
> index 2414782f1eb6..d71e041010ad 100644
> --- a/drivers/media/platform/verisilicon/hantro_h264.c
> +++ b/drivers/media/platform/verisilicon/hantro_h264.c
> @@ -453,13 +453,11 @@ int hantro_h264_dec_prepare_run(struct hantro_ctx *ctx)
> if (WARN_ON(!ctrls->decode))
> return -EINVAL;
>
> - ctrls->sps =
> - hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_SPS);
> + ctrls->sps = hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_SPS);
> if (WARN_ON(!ctrls->sps))
> return -EINVAL;
>
> - ctrls->pps =
> - hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_PPS);
> + ctrls->pps = hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_PPS);
> if (WARN_ON(!ctrls->pps))
> return -EINVAL;
>
> diff --git a/drivers/media/platform/verisilicon/hantro_hw.h b/drivers/media/platform/verisilicon/hantro_hw.h
> index c9b6556f8b2b..a0c752ef44dd 100644
> --- a/drivers/media/platform/verisilicon/hantro_hw.h
> +++ b/drivers/media/platform/verisilicon/hantro_hw.h
> @@ -12,11 +12,13 @@
> #include <linux/interrupt.h>
> #include <linux/v4l2-controls.h>
> #include <media/v4l2-ctrls.h>
> +#include <media/v4l2-h264-enc.h>
> #include <media/v4l2-vp9.h>
> #include <media/videobuf2-core.h>
>
> #include "rockchip_av1_entropymode.h"
> #include "rockchip_av1_filmgrain.h"
> +#include "hantro_vc8000e_regs.h"
>
> #define DEC_8190_ALIGN_MASK 0x07U
>
> @@ -69,6 +71,22 @@ struct hantro_aux_buf {
> unsigned long attrs;
> };
>
> +struct hantro_vc8000e_rec_buf {
> + struct hantro_aux_buf luma;
> + struct hantro_aux_buf chroma;
> + struct hantro_aux_buf luma_4n;
> + struct hantro_aux_buf colctbs;
> +};
> +
> +struct hantro_h264_enc_hw_ctx {
> + struct v4l2_h264_enc enc;
> + struct hantro_aux_buf nal_tbl;
> +
> + union {
> + struct hantro_vc8000e_regs vc8000e_regs;
> + };
> +};
> +
> /* Max. number of entries in the DPB (HW limitation). */
> #define HANTRO_H264_DPB_SIZE 16
>
> @@ -451,6 +469,15 @@ int hantro_g1_h264_dec_run(struct hantro_ctx *ctx);
> int hantro_h264_dec_init(struct hantro_ctx *ctx);
> void hantro_h264_dec_exit(struct hantro_ctx *ctx);
>
> +irqreturn_t hantro_vc8000e_irq(int irq, void *dev_id);
> +int hantro_vc8000e_h264_enc_init(struct hantro_ctx *ctx);
> +void hantro_vc8000e_h264_enc_exit(struct hantro_ctx *ctx);
> +void hantro_vc8000e_h264_enc_done(struct hantro_ctx *ctx);
> +int hantro_vc8000e_h264_enc_run(struct hantro_ctx *ctx);
> +int hantro_h264_enc_prepare_run(struct hantro_ctx *ctx);
> +int hantro_h264_enc_init(struct hantro_ctx *ctx);
> +void hantro_h264_enc_exit(struct hantro_ctx *ctx);
> +
> int hantro_hevc_dec_init(struct hantro_ctx *ctx);
> void hantro_hevc_dec_exit(struct hantro_ctx *ctx);
> int hantro_g2_hevc_dec_run(struct hantro_ctx *ctx);
> diff --git a/drivers/media/platform/verisilicon/hantro_v4l2.c b/drivers/media/platform/verisilicon/hantro_v4l2.c
> index 2125f2913d9a..96b72c1f37db 100644
> --- a/drivers/media/platform/verisilicon/hantro_v4l2.c
> +++ b/drivers/media/platform/verisilicon/hantro_v4l2.c
> @@ -629,6 +629,12 @@ static int hantro_set_fmt_out(struct hantro_ctx *ctx,
> hantro_get_format_depth(pix_mp->pixelformat),
> need_postproc);
>
> + /* Propagate dimensions for encoders. */
> + if (ctx->is_encoder) {
> + ctx->dst_fmt.width = pix_mp->width;
> + ctx->dst_fmt.height = pix_mp->height;
> + }
> +
> /* Colorimetry information are always propagated. */
> ctx->dst_fmt.colorspace = pix_mp->colorspace;
> ctx->dst_fmt.ycbcr_enc = pix_mp->ycbcr_enc;
> diff --git a/drivers/media/platform/verisilicon/hantro_vc8000e.c b/drivers/media/platform/verisilicon/hantro_vc8000e.c
> new file mode 100644
> index 000000000000..ebd726e13460
> --- /dev/null
> +++ b/drivers/media/platform/verisilicon/hantro_vc8000e.c
> @@ -0,0 +1,68 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Hantro VPU codec driver
> + *
> + * Copyright (C) 2025-2026 Paul Kocialkowski <paulk@sys-base.io>
> + */
> +
> +#include "hantro.h"
> +#include "hantro_vc8000e_regs.h"
> +
> +irqreturn_t hantro_vc8000e_irq(int irq, void *dev_id)
> +{
> + struct hantro_dev *vpu = dev_id;
> + u32 regs_buffer[HANTRO_VC8000E_SWREG_OFFSET(swreg6) / 4];
> + struct hantro_vc8000e_regs *regs =
> + (struct hantro_vc8000e_regs *)regs_buffer;
> + enum vb2_buffer_state state;
> +
> + hantro_vc8000e_swreg_read(vpu, regs, swreg1);
> +
> + pr_debug("+ hantro-vc8000e-irq: %#x\n",
vpu_debug() ? and drop the +?
> + regs_buffer[HANTRO_VC8000E_SWREG_OFFSET(swreg1) / 4]);
> +
> + if (regs->swreg1.irq)
> + pr_debug(" - irq\n");
> + if (regs->swreg1.frame_rdy_status)
> + pr_debug(" - frame ready\n");
> + if (regs->swreg1.bus_error_status)
> + pr_debug(" - bus error\n");
> + if (regs->swreg1.sw_reset)
> + pr_debug(" - sw reset\n");
> + if (regs->swreg1.buffer_full)
> + pr_debug(" - buffer full\n");
> + if (regs->swreg1.timeout)
> + pr_debug(" - timeout\n");
> + if (regs->swreg1.slice_rdy_status)
> + pr_debug(" - slice ready\n");
> + if (regs->swreg1.irq_fuse_error)
> + pr_debug(" - fuse error\n");
> + if (regs->swreg1.strm_segment_rdy_int)
> + pr_debug(" - segment ready\n");
We rate limit these, and to follow vpu_debug(), it should be backed by dev_dbg,
so dev_dbg_ratelimited().
> +
> + hantro_vc8000e_swreg_read(vpu, regs, swreg4);
> + hantro_vc8000e_swreg_read(vpu, regs, swreg5);
> +
> + /* Make sure to disble the encoder on error for safety. */
> + if ((regs->swreg1.bus_error_status ||
> + regs->swreg1.buffer_full ||
> + regs->swreg1.timeout ||
> + regs->swreg1.irq_fuse_error) &&
> + (regs->swreg4.mode == HANTRO_VC8000E_SWREG4_MODE_H264 ||
> + regs->swreg4.mode == HANTRO_VC8000E_SWREG4_MODE_HEVC)) {
> + regs->swreg5.enable = 0;
> + hantro_vc8000e_swreg_write(vpu, regs, swreg5);
> + }
> +
> + state = regs->swreg1.frame_rdy_status ? VB2_BUF_STATE_DONE :
> + VB2_BUF_STATE_ERROR;
> +
> + regs->swreg1.irq_dis = 1;
> + regs->swreg1.timeout_int = 0;
> +
> + hantro_vc8000e_swreg_write(vpu, regs, swreg1);
> +
> + hantro_irq_done(vpu, state);
> +
> + return IRQ_HANDLED;
> +}
> diff --git a/drivers/media/platform/verisilicon/hantro_vc8000e_h264_enc.c b/drivers/media/platform/verisilicon/hantro_vc8000e_h264_enc.c
> new file mode 100644
> index 000000000000..d3522d61443d
> --- /dev/null
> +++ b/drivers/media/platform/verisilicon/hantro_vc8000e_h264_enc.c
> @@ -0,0 +1,883 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Hantro VPU codec driver
> + *
> + * Copyright (C) 2024 Pengutronix, Marco Felsch <kernel@pengutronix.de>
> + * Copyright (C) 2025-2026 Paul Kocialkowski <paulk@sys-base.io>
> + */
> +
> +#include <linux/unaligned.h>
> +#include <linux/delay.h>
> +#include <media/v4l2-mem2mem.h>
> +#include <media/v4l2-h264-enc-rbsp.h>
> +
> +#include "hantro.h"
> +#include "hantro_hw.h"
> +#include "hantro_vc8000e_regs.h"
> +
> +static int
> +hantro_vc8000e_h264_enc_state_constrain(struct v4l2_h264_enc *enc,
> + struct v4l2_h264_enc_state *state)
> +{
> + struct v4l2_ctrl_h264_sps *sps = &state->sps;
> + struct v4l2_ctrl_h264_pps *pps = &state->pps;
> + struct v4l2_ctrl_h264_encode_params *encode = &state->encode;
> +
> + /* SPS */
> +
> + if (V4L2_H264_SPS_HAS_CHROMA_FORMAT(sps)) {
> + sps->chroma_format_idc = 1;
> + sps->flags &= ~V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE;
> + sps->bit_depth_luma_minus8 = 0;
> + sps->bit_depth_chroma_minus8 = 0;
> + sps->flags &= ~V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS;
> + }
> +
> + /* Only one reference frame is currently supported. */
> + if (sps->max_num_ref_frames > 1)
> + sps->max_num_ref_frames = 1;
> +
> + if (!(sps->flags & V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY)) {
> + sps->flags |= V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY;
> + sps->flags &= ~V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD;
> + }
> +
> + sps->flags |= V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE;
> +
> + /* PPS */
> +
> + /* Only one reference frame is currently supported. */
> + pps->num_ref_idx_l0_default_active_minus1 = 0;
> + pps->num_ref_idx_l1_default_active_minus1 = 0;
> +
> + /* Encode */
> +
> + /* Only a single bit is available for idr_pic_id. */
> + if (encode->flags & V4L2_H264_ENCODE_FLAG_IDR_PIC)
> + encode->idr_pic_id &= 1;
> +
> + /* The hardware doesn't allow overriding the active list numbers. */
> + if (encode->flags & V4L2_H264_SLICE_FLAG_NUM_REF_IDX_ACTIVE_OVERRIDE) {
> + encode->flags &= ~V4L2_H264_SLICE_FLAG_NUM_REF_IDX_ACTIVE_OVERRIDE;
> +
> + encode->num_ref_idx_l0_active_minus1 = 0;
> + encode->num_ref_idx_l1_active_minus1 = 0;
> + }
> +
> + /* Only a single bit is available for cabac_init_idc. */
> + if (encode->cabac_init_idc > 1)
> + encode->cabac_init_idc = 1;
> +
> + /* Only a single bit is available for disable_deblocking_filter_idc. */
> + if (encode->disable_deblocking_filter_idc > 1)
> + encode->disable_deblocking_filter_idc = 1;
> +
> + return 0;
> +}
> +
> +static int
> +hantro_vc8000e_h264_enc_rec_buffer_alloc(struct v4l2_h264_enc *enc,
> + struct v4l2_h264_enc_rec_buffer *buffer)
> +{
> + struct hantro_ctx *ctx = enc->private_data;
> + struct device *dev = ctx->dev->dev;
> + struct hantro_vc8000e_rec_buf *rec_buf;
> + unsigned int width_mbs, height_mbs;
> +
> + width_mbs = MB_WIDTH(ctx->src_fmt.width);
> + height_mbs = MB_HEIGHT(ctx->src_fmt.height);
> +
> + rec_buf = kzalloc(sizeof(*rec_buf), GFP_KERNEL);
> + if (!rec_buf)
> + goto error;
> +
> + rec_buf->luma.size = ctx->src_fmt.width * ctx->src_fmt.height;
> + rec_buf->luma.cpu = dma_alloc_coherent(dev, rec_buf->luma.size,
> + &rec_buf->luma.dma, GFP_KERNEL);
> + if (!rec_buf->luma.cpu)
> + goto error;
> +
> + rec_buf->chroma.size = rec_buf->luma.size / 2;
> + rec_buf->chroma.cpu = dma_alloc_coherent(dev, rec_buf->chroma.size,
> + &rec_buf->chroma.dma,
> + GFP_KERNEL);
> + if (!rec_buf->chroma.cpu)
> + goto error;
> +
> + rec_buf->luma_4n.size = width_mbs * 4 * height_mbs * 4;
> + rec_buf->luma_4n.cpu = dma_alloc_coherent(dev, rec_buf->luma_4n.size,
> + &rec_buf->luma_4n.dma,
> + GFP_KERNEL);
> + if (!rec_buf->luma_4n.cpu)
> + goto error;
> +
> + rec_buf->colctbs.size = DIV_ROUND_UP(width_mbs * height_mbs, 2);
> + rec_buf->colctbs.cpu = dma_alloc_coherent(dev, rec_buf->colctbs.size,
> + &rec_buf->colctbs.dma,
> + GFP_KERNEL);
> + if (!rec_buf->colctbs.cpu)
> + goto error;
> +
> + buffer->private_data = rec_buf;
> +
> + return 0;
> +
> +error:
> + if (rec_buf)
> + kfree(rec_buf);
> +
> + return -ENOMEM;
> +}
> +
> +static int
> +hantro_vc8000e_h264_enc_rec_buffer_free(struct v4l2_h264_enc *enc,
> + struct v4l2_h264_enc_rec_buffer *buffer)
> +{
> + struct hantro_ctx *ctx = enc->private_data;
> + struct device *dev = ctx->dev->dev;
> + struct hantro_vc8000e_rec_buf *rec_buf = buffer->private_data;
> +
> + if (!rec_buf)
> + return -EINVAL;
> +
> + dma_free_coherent(dev, rec_buf->luma.size, rec_buf->luma.cpu,
> + rec_buf->luma.dma);
> +
> + dma_free_coherent(dev, rec_buf->luma_4n.size, rec_buf->luma_4n.cpu,
> + rec_buf->luma_4n.dma);
> +
> + dma_free_coherent(dev, rec_buf->chroma.size, rec_buf->chroma.cpu,
> + rec_buf->chroma.dma);
> +
> + dma_free_coherent(dev, rec_buf->colctbs.size, rec_buf->colctbs.cpu,
> + rec_buf->colctbs.dma);
> +
> + kfree(rec_buf);
> + buffer->private_data = NULL;
> +
> + return 0;
> +}
> +
> +static const struct v4l2_h264_enc_ops hantro_vc8000e_h264_enc_ops = {
> + .state_constrain = hantro_vc8000e_h264_enc_state_constrain,
> + .rec_buffer_alloc = hantro_vc8000e_h264_enc_rec_buffer_alloc,
> + .rec_buffer_free = hantro_vc8000e_h264_enc_rec_buffer_free,
> +};
> +
> +int hantro_vc8000e_h264_enc_init(struct hantro_ctx *ctx)
> +{
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_aux_buf *nal_tbl = &h264_ctx->nal_tbl;
> + struct v4l2_h264_enc *enc = &h264_ctx->enc;
> + struct device *dev = ctx->dev->dev;
> +
> + nal_tbl->size = ALIGN(MB_HEIGHT(ctx->src_fmt.height), 8);
> + nal_tbl->cpu = dma_alloc_coherent(dev, nal_tbl->size,
> + &nal_tbl->dma, GFP_KERNEL);
> + if (!nal_tbl->cpu)
> + return -ENOMEM;
> +
> + enc->ops = &hantro_vc8000e_h264_enc_ops;
> + enc->private_data = ctx;
> + enc->format_mplane = &ctx->dst_fmt;
> + enc->timeperframe = &ctx->dst_timeperframe;
> + enc->ctrl_handler = &ctx->ctrl_handler;
> + enc->ref_slots_count_init = 2;
> + enc->flags = V4L2_H264_ENC_FLAG_INTER_PRED |
> + V4L2_H264_ENC_FLAG_HW_SLICE_HEADER;
> +
> + return v4l2_h264_enc_init(enc);
> +}
> +
> +void hantro_vc8000e_h264_enc_exit(struct hantro_ctx *ctx)
> +{
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_aux_buf *nal_tbl = &h264_ctx->nal_tbl;
> + struct device *dev = ctx->dev->dev;
> +
> + if (nal_tbl->cpu)
> + dma_free_coherent(dev, nal_tbl->size, nal_tbl->cpu,
> + nal_tbl->dma);
> +
> + v4l2_h264_enc_exit(&h264_ctx->enc);
> +}
> +
> +static int ref_setup(struct hantro_ctx *ctx)
> +{
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_vc8000e_regs *regs = &h264_ctx->vc8000e_regs;
> + struct v4l2_h264_enc *enc = &h264_ctx->enc;
> + struct v4l2_h264_enc_ref *ref = &enc->ref;
> + struct v4l2_h264_enc_state *state = &enc->state_active;
> + struct v4l2_ctrl_h264_encode_params *encode = &state->encode;
> + struct v4l2_h264_dpb_entry *dpb_entry;
> + struct v4l2_h264_enc_rec_buffer *buffer;
> + struct hantro_vc8000e_rec_buf *rec_buf;
> + bool ltr_present = false;
> + unsigned int index;
> +
> + regs->swreg193.nal_ref_idc = encode->nal_ref_idc != 0;
> +
> + if (encode->flags & V4L2_H264_ENCODE_FLAG_LONG_TERM_REFERENCE) {
> + regs->swreg198.mark_current_longterm = 1;
> + /* We only get a single long-term reference without MMCO. */
> + regs->swreg194.cur_longtermidx = 0;
> + }
> +
> + regs->swreg193.l0_used_by_next_pic0 = 1;
> + regs->swreg193.l0_used_by_next_pic1 = 1;
> + regs->swreg194.l1_used_by_next_pic0 = 1;
> + regs->swreg194.l1_used_by_next_pic1 = 1;
> +
> + regs->swreg17.active_l0_cnt = ref->l0_active_count;
> + regs->swreg91.active_l1_cnt = ref->l1_active_count;
> + regs->swreg4.active_override_flag = 1;
> +
> + if (ref->l0_active_count > 0) {
> + index = ref->l0[0].index;
> + dpb_entry = &ref->dpb[index];
> + buffer = &ref->buffers[index];
> + rec_buf = buffer->private_data;
> +
> + regs->swreg18.refpic_recon_l0_y0 = rec_buf->luma.dma;
> + regs->swreg19.refpic_recon_l0_chroma0 = rec_buf->chroma.dma;
> + regs->swreg74.refpic_recon_l0_4n0_base = rec_buf->luma_4n.dma;
> +
> + regs->swreg17.l0_used_by_curr_pic0 = 1;
> + /* TODO: diff with wrap. */
> + regs->swreg17.l0_delta_poc0 = 1;
> + regs->swreg193.l0_delta_framenum0 = 1;
> +
> + if (dpb_entry->flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM) {
> + regs->swreg17.l0_long_term_flag0 = 1;
> + regs->swreg198.l0_longtermidx0 = 0;
> + ltr_present = true;
> + }
> + }
> +
> + if (ref->l0_active_count > 1) {
> + index = ref->l0[1].index;
> + dpb_entry = &ref->dpb[index];
> + buffer = &ref->buffers[index];
> + rec_buf = buffer->private_data;
> +
> + regs->swreg20.refpic_recon_l0_y1 = rec_buf->luma.dma;
> + regs->swreg21.refpic_recon_l0_chroma1 = rec_buf->chroma.dma;
> + regs->swreg76.refpic_recon_l0_4n1_base = rec_buf->luma_4n.dma;
> +
> + regs->swreg17.l0_used_by_curr_pic1 = 1;
> + /* TODO: diff with wrap. */
> + regs->swreg17.l0_delta_poc1 = 1;
> + regs->swreg193.l0_delta_framenum1 = 1;
> +
> + if (dpb_entry->flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM) {
> + regs->swreg17.l0_long_term_flag1 = 1;
> + regs->swreg198.l0_longtermidx1 = 0;
> + ltr_present = true;
> + }
> + }
> +
> + if (ltr_present)
> + regs->swreg91.long_term_ref_pics_present_flag = 1;
> +
> + return 0;
> +}
> +
> +static int lambda_setup(struct hantro_ctx *ctx)
> +{
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_vc8000e_regs *regs = &h264_ctx->vc8000e_regs;
> +
> + /* Intra SATD */
> +
> + regs->swreg125.intra_satd_lambda_0 = 0x47;
> + regs->swreg125.intra_satd_lambda_1 = 0x3f;
> + regs->swreg126.intra_satd_lambda_2 = 0x38;
> + regs->swreg126.intra_satd_lambda_3 = 0x32;
> + regs->swreg127.intra_satd_lambda_4 = 0;
> + regs->swreg127.intra_satd_lambda_5 = 0;
> + regs->swreg128.intra_satd_lambda_6 = 0;
> + regs->swreg128.intra_satd_lambda_7 = 0;
> + regs->swreg129.intra_satd_lambda_8 = 0;
> + regs->swreg129.intra_satd_lambda_9 = 0;
> + regs->swreg130.intra_satd_lambda_10 = 0;
> + regs->swreg130.intra_satd_lambda_11 = 0;
> + regs->swreg131.intra_satd_lambda_12 = 0;
> + regs->swreg131.intra_satd_lambda_13 = 0;
> + regs->swreg132.intra_satd_lambda_14 = 0;
> + regs->swreg132.intra_satd_lambda_15 = 0;
> + regs->swreg174.intra_satd_lambda_16 = 0x1c4;
> + regs->swreg174.intra_satd_lambda_17 = 0x192;
> + regs->swreg175.intra_satd_lambda_18 = 0x166;
> + regs->swreg175.intra_satd_lambda_19 = 0x13f;
> + regs->swreg176.intra_satd_lambda_20 = 0x11c;
> + regs->swreg176.intra_satd_lambda_21 = 0xfd;
> + regs->swreg177.intra_satd_lambda_22 = 0xe2;
> + regs->swreg177.intra_satd_lambda_23 = 0xc9;
> + regs->swreg178.intra_satd_lambda_24 = 0xb3;
> + regs->swreg178.intra_satd_lambda_25 = 0xa0;
> + regs->swreg179.intra_satd_lambda_26 = 0x8e;
> + regs->swreg179.intra_satd_lambda_27 = 0x7f;
> + regs->swreg180.intra_satd_lambda_28 = 0x71;
> + regs->swreg180.intra_satd_lambda_29 = 0x65;
> + regs->swreg181.intra_satd_lambda_30 = 0x5a;
> + regs->swreg181.intra_satd_lambda_31 = 0x50;
> +
> + /* Inter SATD */
> +
> + regs->swreg28.lambda_satd_me_0 = 0x24;
> + regs->swreg28.lambda_satd_me_1 = 0x20;
> + regs->swreg29.lambda_satd_me_2 = 0x1c;
> + regs->swreg29.lambda_satd_me_3 = 0x19;
> + regs->swreg30.lambda_satd_me_4 = 0x16;
> + regs->swreg30.lambda_satd_me_5 = 0x14;
> + regs->swreg31.lambda_satd_me_6 = 0x12;
> + regs->swreg31.lambda_satd_me_7 = 0x10;
> + regs->swreg32.lambda_satd_me_8 = 0xe;
> + regs->swreg32.lambda_satd_me_9 = 0xd;
> + regs->swreg33.lambda_satd_me_10 = 0xb;
> + regs->swreg33.lambda_satd_me_11 = 0xa;
> + regs->swreg34.lambda_satd_me_12 = 0x9;
> + regs->swreg34.lambda_satd_me_13 = 0x8;
> + regs->swreg78.lambda_satd_me_14 = 0x7;
> + regs->swreg78.lambda_satd_me_15 = 0x6;
> + regs->swreg150.lambda_satd_me_16 = 0;
> + regs->swreg150.lambda_satd_me_17 = 0;
> + regs->swreg151.lambda_satd_me_18 = 0;
> + regs->swreg151.lambda_satd_me_19 = 0;
> + regs->swreg152.lambda_satd_me_20 = 0x88;
> + regs->swreg152.lambda_satd_me_21 = 0;
> + regs->swreg153.lambda_satd_me_22 = 0;
> + regs->swreg153.lambda_satd_me_23 = 0;
> + regs->swreg154.lambda_satd_me_24 = 0;
> + regs->swreg154.lambda_satd_me_25 = 0;
> + regs->swreg155.lambda_satd_me_26 = 0;
> + regs->swreg155.lambda_satd_me_27 = 0;
> + regs->swreg156.lambda_satd_me_28 = 0;
> + regs->swreg156.lambda_satd_me_29 = 0;
> + regs->swreg157.lambda_satd_me_30 = 0;
> + regs->swreg157.lambda_satd_me_31 = 0;
> +
> + /* Inter SSE */
> +
> + regs->swreg79.lambda_sse_me_0 = 0x4f;
> + regs->swreg122.lambda_sse_me_1 = 0x3f;
> + regs->swreg123.lambda_sse_me_2 = 0x32;
> + regs->swreg124.lambda_sse_me_3 = 0x28;
> + regs->swreg138.lambda_sse_me_4 = 0;
> + regs->swreg139.lambda_sse_me_5 = 0;
> + regs->swreg140.lambda_sse_me_6 = 0;
> + regs->swreg141.lambda_sse_me_7 = 0;
> + regs->swreg142.lambda_sse_me_8 = 0;
> + regs->swreg143.lambda_sse_me_9 = 0;
> + regs->swreg144.lambda_sse_me_10 = 0;
> + regs->swreg145.lambda_sse_me_11 = 0;
> + regs->swreg146.lambda_sse_me_12 = 0;
> + regs->swreg147.lambda_sse_me_13 = 0;
> + regs->swreg148.lambda_sse_me_14 = 0;
> + regs->swreg149.lambda_sse_me_15 = 0;
> + regs->swreg158.lambda_sse_me_16 = 0;
> + regs->swreg159.lambda_sse_me_17 = 0x800;
> + regs->swreg160.lambda_sse_me_18 = 0;
> + regs->swreg161.lambda_sse_me_19 = 0;
> + regs->swreg162.lambda_sse_me_20 = 0;
> + regs->swreg163.lambda_sse_me_21 = 0;
> + regs->swreg164.lambda_sse_me_22 = 0;
> + regs->swreg165.lambda_sse_me_23 = 0;
> + regs->swreg166.lambda_sse_me_24 = 0;
> + regs->swreg167.lambda_sse_me_25 = 0;
> + regs->swreg168.lambda_sse_me_26 = 0x13c;
> + regs->swreg169.lambda_sse_me_27 = 0xfb;
> + regs->swreg172.lambda_sse_me_30 = 0x7d;
> + regs->swreg173.lambda_sse_me_31 = 0x64;
> +
> + regs->swreg35.lambda_motion_sse = 0;
> +
> + if (regs->swreg214.hwabsqpsupport) {
> + /* Used for lambda calculation, different intra/inter value. */
> + regs->swreg170_qp_absolute.sse_qp_factor = 0x1f5c;
> + regs->swreg171_qp_absolute.sad_qp_factor = 0x2ccd;
> + }
> +
> + return 0;
> +}
> +
> +static int areas_setup(struct hantro_ctx *ctx)
> +{
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_vc8000e_regs *regs = &h264_ctx->vc8000e_regs;
> +
> + /* Intra */
> +
> + regs->swreg23.intra_area_left = 0xff;
> + regs->swreg195.intra_area_left_msb = 1;
> + regs->swreg249.intra_area_left_msb2 = 1;
> +
> + regs->swreg23.intra_area_right = 0xff;
> + regs->swreg195.intra_area_right_msb = 1;
> + regs->swreg249.intra_area_right_msb2 = 1;
> +
> + regs->swreg23.intra_area_top = 0xff;
> + regs->swreg195.intra_area_top_msb = 1;
> + regs->swreg249.intra_area_top_msb2 = 1;
> +
> + regs->swreg23.intra_area_bottom = 0xff;
> + regs->swreg195.intra_area_bottom_msb = 1;
> + regs->swreg249.intra_area_bottom_msb2 = 1;
> +
> + /* IPCM1 */
> +
> + regs->swreg208_h264.ipcm1_left = 0x1ff;
> + regs->swreg249.ipcm1_left_msb = 1;
> +
> + regs->swreg209.ipcm1_right = 0x1ff;
> + regs->swreg249.ipcm1_right_msb = 1;
> +
> + regs->swreg209.ipcm1_top = 0x1ff;
> + regs->swreg209.ipcm1_bottom = 0x1ff;
> +
> + regs->swreg249.ipcm1_top_msb = 1;
> + regs->swreg249.ipcm1_bottom_msb = 1;
> +
> + /* IPCM2 */
> +
> + regs->swreg210.ipcm2_left = 0x1ff;
> + regs->swreg249.ipcm2_left_msb = 1;
> +
> + regs->swreg211.ipcm2_right = 0x1ff;
> + regs->swreg249.ipcm2_right_msb = 1;
> +
> + regs->swreg212.ipcm2_top = 0x1ff;
> + regs->swreg249.ipcm2_top_msb = 1;
> +
> + regs->swreg213.ipcm2_bottom = 0x1ff;
> + regs->swreg249.ipcm2_bottom_msb = 1;
> +
> + /* ROI1 */
> +
> + regs->swreg24.roi1_left = 0xff;
> + regs->swreg195.roi1_left_msb = 1;
> + regs->swreg249.roi1_left_msb2 = 1;
> +
> + regs->swreg24.roi1_right = 0xff;
> + regs->swreg195.roi1_right_msb = 1;
> + regs->swreg249.roi1_right_msb2 = 1;
> +
> + regs->swreg24.roi1_top = 0xff;
> + regs->swreg195.roi1_top_msb = 1;
> + regs->swreg249.roi1_top_msb2 = 1;
> +
> + regs->swreg24.roi1_bottom = 0xff;
> + regs->swreg195.roi1_bottom_msb = 1;
> + regs->swreg249.roi1_bottom_msb2 = 1;
> +
> + /* ROI2 */
> +
> + regs->swreg25.roi2_left = 0xff;
> + regs->swreg195.roi2_left_msb = 1;
> + regs->swreg249.roi2_left_msb2 = 1;
> +
> + regs->swreg25.roi2_right = 0xff;
> + regs->swreg195.roi2_right_msb = 1;
> + regs->swreg249.roi2_right_msb2 = 1;
> +
> + regs->swreg25.roi2_top = 0xff;
> + regs->swreg195.roi2_top_msb = 1;
> + regs->swreg249.roi2_top_msb2 = 1;
> +
> + regs->swreg25.roi2_bottom = 0xff;
> + regs->swreg195.roi2_bottom_msb = 1;
> + regs->swreg249.roi2_bottom_msb2 = 1;
> +
> + if (regs->swreg226.hwroi8support) {
> + /* ROI3 */
> +
> + regs->swreg252.roi3_left = 0x3ff;
> + regs->swreg252.roi3_right = 0x3ff;
> + regs->swreg252.roi3_top = 0x3ff;
> + regs->swreg253.roi3_bottom = 0x3ff;
> +
> + /* ROI4 */
> +
> + regs->swreg253.roi4_left = 0x3ff;
> + regs->swreg254.roi4_right = 0x3ff;
> + regs->swreg253.roi4_top = 0x3ff;
> + regs->swreg254.roi4_bottom = 0x3ff;
> +
> + /* ROI5 */
> +
> + regs->swreg254.roi5_left = 0x3ff;
> + regs->swreg255.roi5_right = 0x3ff;
> + regs->swreg255.roi5_top = 0x3ff;
> + regs->swreg255.roi5_bottom = 0x3ff;
> +
> + /* ROI6 */
> +
> + regs->swreg256.roi6_left = 0x3ff;
> + regs->swreg256.roi6_right = 0x3ff;
> + regs->swreg256.roi6_top = 0x3ff;
> + regs->swreg257.roi6_bottom = 0x3ff;
> +
> + /* ROI7 */
> +
> + regs->swreg257.roi7_left = 0x3ff;
> + regs->swreg258.roi7_right = 0x3ff;
> + regs->swreg257.roi7_top = 0x3ff;
> + regs->swreg258.roi7_bottom = 0x3ff;
> +
> + /* ROI8 */
> +
> + regs->swreg258.roi8_left = 0x3ff;
> + regs->swreg259.roi8_right = 0x3ff;
> + regs->swreg259.roi8_top = 0x3ff;
> + regs->swreg259.roi8_bottom = 0x3ff;
> + }
> +
> + return 0;
> +}
> +
> +int hantro_vc8000e_h264_enc_run(struct hantro_ctx *ctx)
> +{
> + struct hantro_dev *vpu = ctx->dev;
> + struct v4l2_pix_format_mplane *src_fmt = &ctx->src_fmt;
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_vc8000e_regs *regs = &h264_ctx->vc8000e_regs;
> + struct v4l2_h264_enc *enc = &h264_ctx->enc;
> + struct v4l2_h264_enc_state *state = &enc->state_active;
> + const struct v4l2_ctrl_h264_sps *sps;
> + const struct v4l2_ctrl_h264_pps *pps;
> + const struct v4l2_ctrl_h264_encode_params *encode;
> + struct vb2_v4l2_buffer *src_buf, *dst_buf;
> + struct hantro_vc8000e_rec_buf *rec_buf;
> + const struct v4l2_format_info *info;
> + unsigned int luma_stride;
> + unsigned int chroma_stride;
> + int ret;
> +
> + hantro_start_prepare_run(ctx);
> +
> + info = v4l2_format_info(src_fmt->pixelformat);
> + if (!info)
> + return -EINVAL;
> +
> + src_buf = hantro_get_src_buf(ctx);
> + dst_buf = hantro_get_dst_buf(ctx);
> +
> + ret = v4l2_h264_enc_step(enc, dst_buf);
> + if (ret)
> + return ret;
> +
> + sps = &state->sps;
> + pps = &state->pps;
> + encode = &state->encode;
> +
> + memset(regs, 0, sizeof(*regs));
> +
> + /* Read relevant read-only registers. */
> + hantro_vc8000e_swreg_read(vpu, regs, swreg0);
> + hantro_vc8000e_swreg_read(vpu, regs, swreg80);
> + hantro_vc8000e_swreg_read(vpu, regs, swreg214);
> + hantro_vc8000e_swreg_read(vpu, regs, swreg226);
> + hantro_vc8000e_swreg_read(vpu, regs, swreg287);
> +
> + /* Mode */
> +
> + if (!regs->swreg80.hwh264support)
> + return -ENODEV;
> +
> + regs->swreg4.mode = HANTRO_VC8000E_SWREG4_MODE_H264;
> +
> + /* Input */
> +
> + regs->swreg38.input_format = ctx->vpu_src_fmt->enc_fmt;
> + regs->swreg38.input_rotation = HANTRO_VC8000E_SWREG38_INPUT_ROTATION_0;
> +
> + luma_stride = src_fmt->plane_fmt[0].bytesperline;
> +
> + /*
> + * The hardware seems to expect the luma stride to represent pixels per
> + * line for packed cases, instead of the usual bytes per line.
> + */
> + if (info->comp_planes == 1)
> + luma_stride /= info->bpp[0];
> +
> + regs->swreg210.input_lu_stride = luma_stride;
> +
> + if (info->comp_planes > 1) {
> + if (src_fmt->num_planes > 1)
> + chroma_stride = src_fmt->plane_fmt[1].bytesperline;
> + else if (info->comp_planes > 2)
> + chroma_stride = luma_stride / 2;
> + else
> + chroma_stride = luma_stride;
> +
> + regs->swreg211.input_ch_stride = chroma_stride;
> + }
> +
> + regs->swreg12.input_y_base =
> + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
> +
> + if (info->comp_planes > 1) {
> + if (src_fmt->num_planes > 1)
> + regs->swreg13.input_cb_base =
> + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf,
> + 1);
> + else
> + regs->swreg13.input_cb_base =
> + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf,
> + 0) +
> + luma_stride * src_fmt->height;
> + }
> +
> + if (info->comp_planes > 2) {
> + if (src_fmt->num_planes > 1)
> + regs->swreg14.input_cr_base =
> + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf,
> + 2);
> + else
> + regs->swreg14.input_cr_base =
> + vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf,
> + 0) +
> + luma_stride * src_fmt->height +
> + chroma_stride * src_fmt->height;
> + }
> +
> + /* Output */
> +
> + if (enc->rbsp_update & V4L2_H264_ENC_RBSP_UPDATE_START_CODE)
> + regs->swreg4.output_strm_mode =
> + HANTRO_VC8000E_SWREG4_OUTPUT_STRM_MODE_BYTE_STREAM;
> + else
> + regs->swreg4.output_strm_mode =
> + HANTRO_VC8000E_SWREG4_OUTPUT_STRM_MODE_NAL_STREAM;
> +
> + regs->swreg8.output_strm_base =
> + vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0) +
> + v4l2_h264_enc_rbsp_bytes_count(&enc->rbsp);
> + regs->swreg9.output_strm_buffer_limit =
> + vb2_plane_size(&dst_buf->vb2_buf, 0) -
> + v4l2_h264_enc_rbsp_bytes_count(&enc->rbsp);
> +
> + if (!regs->swreg9.output_strm_buffer_limit)
> + return -ENOMEM;
> +
> + regs->swreg10.size_tbl_base = h264_ctx->nal_tbl.dma;
> + regs->swreg6.nal_size_write = 1;
> +
> + regs->swreg196.num_ctb_rows_per_sync = 1;
> +
> + regs->swreg199.hash_type = HANTRO_VC8000E_SWREG199_HASH_TYPE_NONE;
> +
> + /* Picture */
> +
> + regs->swreg5.pic_width = src_fmt->width / 8;
> + regs->swreg5.pic_height = src_fmt->height / 8;
> + regs->swreg38.rowlength = src_fmt->width;
> +
> + regs->swreg281.chroma_format_idc = sps->chroma_format_idc;
> + regs->swreg38.output_bitwidth_lum =
> + HANTRO_VC8000E_SWREG38_OUTPUT_BITWIDTH_LUM_8_BIT;
> +
> + regs->swreg11.poc = enc->ref.pic_order_cnt;
> + regs->swreg277.pic_order_cnt_type = sps->pic_order_cnt_type;
> + if (!sps->pic_order_cnt_type)
> + regs->swreg277.log2_max_pic_order_cnt_lsb =
> + sps->log2_max_pic_order_cnt_lsb_minus4 + 4;
> +
> + regs->swreg192.framenum = encode->frame_num;
> + regs->swreg277.log2_max_frame_num = sps->log2_max_frame_num_minus4 + 4;
> +
> + /* Reconstruction */
> +
> + regs->swreg212.ref_lu_stride = src_fmt->width * 4;
> + regs->swreg237.ref_ch_stride = src_fmt->width * 4;
> + regs->swreg213.ref_ds_lu_stride = src_fmt->width;
> +
> + rec_buf = enc->ref.buffer_current.private_data;
> +
> + regs->swreg15.recon_y_base = rec_buf->luma.dma;
> + regs->swreg16.recon_chroma_base = rec_buf->chroma.dma;
> + regs->swreg72.recon_luma_4n_base = rec_buf->luma_4n.dma;
> + regs->swreg114.colctbs_store_base = rec_buf->colctbs.dma;
> +
> + /* Reference */
> +
> + ret = ref_setup(ctx);
> + if (ret)
> + return ret;
> +
> + /* Slice */
> +
> + if (encode->slice_type == V4L2_H264_SLICE_TYPE_I)
> + regs->swreg5.frame_coding_type =
> + HANTRO_VC8000E_SWREG5_FRAME_CODING_TYPE_I;
> + else if (encode->slice_type == V4L2_H264_SLICE_TYPE_P)
> + regs->swreg5.frame_coding_type =
> + HANTRO_VC8000E_SWREG5_FRAME_CODING_TYPE_P;
> + else
> + return -EINVAL;
> +
> + if (encode->flags & V4L2_H264_ENCODE_FLAG_IDR_PIC) {
> + regs->swreg191.nal_unit_type = V4L2_H264_NALU_TYPE_SLICE_IDR;
> + regs->swreg193.idr_pic_id = encode->idr_pic_id;
> + } else {
> + regs->swreg191.nal_unit_type =
> + V4L2_H264_NALU_TYPE_SLICE_NON_IDR;
> + }
> +
> + regs->swreg191.pps_id = encode->pic_parameter_set_id;
> +
> + /* Quantization */
> +
> + regs->swreg172.qp_min = state->qp_min;
> + regs->swreg173.qp_max = state->qp_max;
> + regs->swreg7.pic_init_qp = pps->pic_init_qp_minus26 + 26;
> + regs->swreg7.pic_qp = enc->rc.qp;
> + regs->swreg4.chroma_qp_offset = pps->chroma_qp_index_offset;
> +
> + /* Coding */
> +
> + if (pps->flags & V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE) {
> + regs->swreg193.entropy_coding_mode = 1;
> + regs->swreg7.cabac_init_flag = encode->cabac_init_idc;
> + }
> +
> + if (pps->flags & V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE)
> + regs->swreg193.transform8x8_enable = 1;
> +
> + if (pps->flags & V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT) {
> + regs->swreg5.pps_deblocking_filter_override_enabled_flag = 1;
> + regs->swreg5.slice_deblocking_filter_override_flag = 1;
> +
> + regs->swreg6.deblocking_filter_dis =
> + encode->disable_deblocking_filter_idc;
> + regs->swreg6.deblocking_tc_offset =
> + encode->slice_alpha_c0_offset_div2;
> + regs->swreg6.deblocking_beta_offset =
> + encode->slice_beta_offset_div2;
> + }
> +
> + regs->swreg4.min_trb_size = HANTRO_VC8000E_SWREG4_TRB_SIZE_4X4;
> + regs->swreg4.max_trb_size = HANTRO_VC8000E_SWREG4_TRB_SIZE_16X16;
> + regs->swreg4.min_cb_size = HANTRO_VC8000E_SWREG4_CB_SIZE_8X8;
> + regs->swreg4.max_cb_size = HANTRO_VC8000E_SWREG4_CB_SIZE_16X16;
> + regs->swreg4.max_trans_hierarchy_depth_inter = 2;
> + regs->swreg4.max_trans_hierarchy_depth_intra = 1;
> +
> + regs->swreg36.bits_est_1n_cu_penalty = 15;
> + regs->swreg35.bits_est_tu_split_penalty = 3;
> +
> + regs->swreg35.bits_est_bias_intra_cu_8 = 22;
> + regs->swreg35.bits_est_bias_intra_cu_16 = 40;
> + regs->swreg36.bits_est_bias_intra_cu_32 = 86;
> + regs->swreg36.bits_est_bias_intra_cu_64 = 304;
> + regs->swreg36.inter_skip_bias = 124;
> +
> + regs->swreg201.mean_thr0 = 5;
> + regs->swreg201.mean_thr1 = 5;
> + regs->swreg201.mean_thr2 = 5;
> + regs->swreg201.mean_thr3 = 5;
> +
> + regs->swreg203_h264.lum_dc_sum_thr = 5;
> + regs->swreg203_h264.cb_dc_sum_thr = 1;
> + regs->swreg203_h264.cr_dc_sum_thr = 1;
> +
> + regs->swreg26.intra_size_factor_0 = 506;
> + regs->swreg26.intra_size_factor_1 = 506;
> + regs->swreg26.intra_size_factor_2 = 709;
> + regs->swreg27.intra_size_factor_3 = 709;
> +
> + regs->swreg27.intra_mode_factor_0 = 24;
> + regs->swreg27.intra_mode_factor_1 = 12;
> + regs->swreg27.intra_mode_factor_2 = 48;
> +
> + regs->swreg182.qp_delta_gain = 313;
> +
> + /* Lambda */
> +
> + ret = lambda_setup(ctx);
> + if (ret)
> + return ret;
> +
> + /* Areas */
> +
> + ret = areas_setup(ctx);
> + if (ret)
> + return ret;
> +
> + /* Urgent thresholds */
> +
> + regs->swreg272.wr_urgent_disable_threshold =
> + HANTRO_VC8000E_SWREG272_URGENT_THRESHOLD_DISABLE;
> + regs->swreg272.wr_urgent_enable_threshold =
> + HANTRO_VC8000E_SWREG272_URGENT_THRESHOLD_DISABLE;
> + regs->swreg272.rd_urgent_disable_threshold =
> + HANTRO_VC8000E_SWREG272_URGENT_THRESHOLD_DISABLE;
> + regs->swreg272.rd_urgent_enable_threshold =
> + HANTRO_VC8000E_SWREG272_URGENT_THRESHOLD_DISABLE;
> +
> + /* AXI bus */
> +
> + regs->swreg81.max_burst = 16;
> + regs->swreg261.axi_read_outstanding_num = 64;
> + regs->swreg246.axi_write_outstanding_num = 64;
> + regs->swreg320.axi_burst_align_rd_lu_ref_prefetch = 1;
> +
> + /* Automatic clock gating */
> +
> + regs->swreg3.clock_gate_inter_h264_e = 1;
> + regs->swreg3.clock_gate_inter_h265_e = 1;
> + regs->swreg3.clock_gate_inter_e = 1;
> + regs->swreg3.clock_gate_encoder_h264_e = 1;
> + regs->swreg3.clock_gate_encoder_h265_e = 1;
> + regs->swreg3.clock_gate_encoder_e = 1;
> +
> + /* IRQ status */
> +
> + regs->swreg1.irq = 1;
> + regs->swreg1.frame_rdy_status = 1;
> + regs->swreg1.bus_error_status = 1;
> + regs->swreg1.sw_reset = 1;
> + regs->swreg1.buffer_full = 1;
> + regs->swreg1.timeout = 1;
> + regs->swreg1.irq_line_buffer = 1;
> + regs->swreg1.slice_rdy_status = 1;
> +
> + /* IRQ */
> +
> + regs->swreg1.irq_dis = 0;
> + regs->swreg1.timeout_int = 1;
> +
> + /* Register write */
> +
> + hantro_io_copy(vpu->enc_base, regs, sizeof(*regs));
> +
> + hantro_end_prepare_run(ctx);
> +
> + /* Enable */
> +
> + regs->swreg5.enable = 1;
> +
> + hantro_vc8000e_swreg_write(vpu, regs, swreg5);
> +
> + return 0;
> +}
> +
> +void hantro_vc8000e_h264_enc_done(struct hantro_ctx *ctx)
> +{
> + struct hantro_dev *vpu = ctx->dev;
> + struct hantro_h264_enc_hw_ctx *h264_ctx = &ctx->h264_enc;
> + struct hantro_vc8000e_regs *regs = &h264_ctx->vc8000e_regs;
> + struct v4l2_h264_enc *enc = &h264_ctx->enc;
> + struct vb2_v4l2_buffer *dst_buf = hantro_get_dst_buf(ctx);
> + u32 bytesused;
> +
> + hantro_vc8000e_swreg_read(vpu, regs, swreg9);
> +
> + bytesused = regs->swreg9.output_strm_buffer_limit +
> + v4l2_h264_enc_rbsp_bytes_count(&enc->rbsp);
> +
> + vb2_set_plane_payload(&dst_buf->vb2_buf, 0, bytesused);
> +
> + v4l2_h264_enc_complete(enc, dst_buf);
> +}
> diff --git a/drivers/media/platform/verisilicon/hantro_vc8000e_regs.h b/drivers/media/platform/verisilicon/hantro_vc8000e_regs.h
> new file mode 100644
> index 000000000000..fad100572708
> --- /dev/null
> +++ b/drivers/media/platform/verisilicon/hantro_vc8000e_regs.h
> @@ -0,0 +1,2129 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Hantro VPU codec driver
> + *
> + * Copyright (C) 2025-2026 Paul Kocialkowski <paulk@sys-base.io>
> + */
> +
> +#ifndef HANTRO_VC8000E_REGS_H_
> +#define HANTRO_VC8000E_REGS_H_
> +
> +#include <linux/types.h>
> +
> +#define HANTRO_VC8000E_SWREG_OFFSET(s) \
> + offsetof(struct hantro_vc8000e_regs, s)
> +
> +#define hantro_vc8000e_swreg_read(v, r, s) \
> + ({ \
> + u32 *pointer = (u32 *)&(r)->s; \
> + *pointer = vepu_read(v, HANTRO_VC8000E_SWREG_OFFSET(s)); \
> + })
> +
> +#define hantro_vc8000e_swreg_write(v, r, s) \
> + ({ \
> + u32 *pointer = (u32 *)&(r)->s; \
> + vepu_write(v, *pointer, HANTRO_VC8000E_SWREG_OFFSET(s)); \
> + })
> +
> +#define HANTRO_VC8000E_SWREG0_MAJOR_NUMBER_V6_0 0x60
> +#define HANTRO_VC8000E_SWREG0_MAJOR_NUMBER_V6_1 0x61
> +#define HANTRO_VC8000E_SWREG0_MAJOR_NUMBER_V6_2 0x62
> +#define HANTRO_VC8000E_SWREG0_PRODUCT_ID_VC8000E 0x8000
> +
> +#define HANTRO_VC8000E_SWREG4_OUTPUT_STRM_MODE_BYTE_STREAM 0x0
> +#define HANTRO_VC8000E_SWREG4_OUTPUT_STRM_MODE_NAL_STREAM 0x1
> +#define HANTRO_VC8000E_SWREG4_TRB_SIZE_4X4 0x0
> +#define HANTRO_VC8000E_SWREG4_TRB_SIZE_8X8 0x1
> +#define HANTRO_VC8000E_SWREG4_TRB_SIZE_16X16 0x2
> +#define HANTRO_VC8000E_SWREG4_TRB_SIZE_32X32 0x3
> +#define HANTRO_VC8000E_SWREG4_CB_SIZE_8X8 0x0
> +#define HANTRO_VC8000E_SWREG4_CB_SIZE_16X16 0x1
> +#define HANTRO_VC8000E_SWREG4_CB_SIZE_32X32 0x2
> +#define HANTRO_VC8000E_SWREG4_CB_SIZE_64X64 0x3
> +#define HANTRO_VC8000E_SWREG4_MODE_HEVC 0x1
> +#define HANTRO_VC8000E_SWREG4_MODE_H264 0x2
> +#define HANTRO_VC8000E_SWREG4_MODE_JPEG 0x4
> +
> +#define HANTRO_VC8000E_SWREG5_FRAME_CODING_TYPE_P 0x0
> +#define HANTRO_VC8000E_SWREG5_FRAME_CODING_TYPE_I 0x1
> +#define HANTRO_VC8000E_SWREG5_FRAME_CODING_TYPE_B 0x2
> +
> +#define HANTRO_VC8000E_SWREG36_OUTPUT_BITWIDTH_CHROMA_8_BIT 0x0
> +#define HANTRO_VC8000E_SWREG36_OUTPUT_BITWIDTH_CHROMA_9_BIT 0x1
> +#define HANTRO_VC8000E_SWREG36_OUTPUT_BITWIDTH_CHROMA_10_BIT 0x2
> +
> +#define HANTRO_VC8000E_SWREG38_OUTPUT_BITWIDTH_LUM_8_BIT 0x0
> +#define HANTRO_VC8000E_SWREG38_OUTPUT_BITWIDTH_LUM_9_BIT 0x1
> +#define HANTRO_VC8000E_SWREG38_OUTPUT_BITWIDTH_LUM_10_BIT 0x2
> +#define HANTRO_VC8000E_SWREG38_INPUT_ROTATION_0 0x0
> +#define HANTRO_VC8000E_SWREG38_INPUT_ROTATION_90 0x1
> +#define HANTRO_VC8000E_SWREG38_INPUT_ROTATION_270 0x2
> +#define HANTRO_VC8000E_SWREG38_INPUT_ROTATION_180 0x3
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_YUV420P 0x0
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_YUV420SP 0x1
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_YUYV422 0x2
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_UYVY422 0x3
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_RGB565 0x4
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_RGB555 0x5
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_RGB444 0x6
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_RGB888 0x7
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_RGB101010 0x8
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_I010 0x9
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_P010 0xa
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_PACKED10BITPLANAR 0xb
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_Y0L2 0xc
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_DAHUAHEVC 0xd
> +#define HANTRO_VC8000E_SWREG38_INPUT_FORMAT_DAHUAH264 0xe
> +
> +#define HANTRO_VC8000E_SWREG80_HWBUSWIDTH_32_BIT 0x0
> +#define HANTRO_VC8000E_SWREG80_HWBUSWIDTH_64_BIT 0x1
> +#define HANTRO_VC8000E_SWREG80_HWBUSWIDTH_128_BIT 0x2
> +#define HANTRO_VC8000E_SWREG80_HWBUS_AHB 0x1
> +#define HANTRO_VC8000E_SWREG80_HWBUS_OCP 0x2
> +#define HANTRO_VC8000E_SWREG80_HWBUS_AXI 0x3
> +#define HANTRO_VC8000E_SWREG80_HWBUS_PCI 0x4
> +#define HANTRO_VC8000E_SWREG80_HWBUS_AXIAHB 0x5
> +#define HANTRO_VC8000E_SWREG80_HWBUS_AXIAPB 0x6
> +
> +#define HANTRO_VC8000E_SWREG_ROI_QP_TYPE_DELTA 0x0
> +#define HANTRO_VC8000E_SWREG_ROI_QP_TYPE_ABSOLUTE 0x1
> +
> +#define HANTRO_VC8000E_SWREG181_RC_BLOCK_SIZE_64X64 0x0
> +#define HANTRO_VC8000E_SWREG181_RC_BLOCK_SIZE_32X32 0x1
> +#define HANTRO_VC8000E_SWREG181_RC_BLOCK_SIZE_16X16 0x2
> +
> +#define HANTRO_VC8000E_SWREG199_HASH_TYPE_NONE 0x0
> +#define HANTRO_VC8000E_SWREG199_HASH_TYPE_CRC32 0x1
> +#define HANTRO_VC8000E_SWREG199_HASH_TYPE_CHECKSUM32 0x2
> +
> +#define HANTRO_VC8000E_SWREG214_HWROIMAPVERSION_4_BPP 0x0
> +#define HANTRO_VC8000E_SWREG214_HWROIMAPVERSION_8_BPP 0x1
> +
> +#define HANTRO_VC8000E_SWREG226_HWINLOOPDSRATIO_1_1 0x0
> +#define HANTRO_VC8000E_SWREG226_HWINLOOPDSRATIO_1_2 0x1
> +#define HANTRO_VC8000E_SWREG226_BFRAME_ME4N_HOR_SEARCHRANGE_64 0x0
> +#define HANTRO_VC8000E_SWREG226_BFRAME_ME4N_HOR_SEARCHRANGE_128 0x1
> +#define HANTRO_VC8000E_SWREG226_BFRAME_ME4N_HOR_SEARCHRANGE_192 0x2
> +#define HANTRO_VC8000E_SWREG226_BFRAME_ME4N_HOR_SEARCHRANGE_256 0x3
> +#define HANTRO_VC8000E_SWREG226_HWP010REFSUPPORT_NORMAL 0x0
> +#define HANTRO_VC8000E_SWREG226_HWP010REFSUPPORT_TILED_P010 0x1
> +
> +#define HANTRO_VC8000E_SWREG272_URGENT_THRESHOLD_DISABLE 0xff
> +
> +#define HANTRO_VC8000E_SWREG281_CHROMA_FORMAT_IDC_400 0x0
> +#define HANTRO_VC8000E_SWREG281_CHROMA_FORMAT_IDC_420 0x1
> +
> +struct hantro_vc8000e_regs {
I like register structure, not everyone do, but I do and I think its good firt
for group of 32 bit. But I also very like consistent code and this bring a third
style to this old driver. Please sync with Benjamin on the direction here and
find a direction. I think he was looking at buffered register, but not regmap
and not bit field.
Nicolas
> + struct {
> + u32 minor_number : 8;
> + u32 major_number : 8;
> + u32 product_id : 16;
> + } swreg0;
> +
> + struct {
> + u32 irq : 1;
> + u32 irq_dis : 1;
> + u32 frame_rdy_status : 1;
> + u32 bus_error_status : 1;
> + u32 sw_reset : 1;
> + u32 buffer_full : 1;
> + u32 timeout : 1;
> + u32 irq_line_buffer : 1;
> + u32 slice_rdy_status : 1;
> + u32 irq_fuse_error : 1;
> + u32 reserved0 : 1;
> + u32 timeout_int : 1;
> + u32 strm_segment_rdy_int : 1;
> + u32 reserved1 : 19;
> + } swreg1;
> +
> + struct {
> + u32 ctb_rc_mem_out_swap : 4;
> + u32 roi_map_qp_delta_map_swap : 4;
> + u32 pic_swap : 4;
> + u32 strm_swap : 4;
> + u32 axi_read_id : 8;
> + u32 axi_write_id : 8;
> + } swreg2;
> +
> + struct {
> + u32 reserved0 : 1;
> + u32 strm_segment_int : 1;
> + u32 line_buffer_int : 1;
> + u32 slice_int : 1;
> + u32 reserved1 : 16;
> + u32 cu_info_mem_out_swap : 4;
> + u32 axi_rd_id_e : 1;
> + u32 axi_wr_id_e : 1;
> + u32 clock_gate_inter_h264_e : 1;
> + u32 clock_gate_inter_h265_e : 1;
> + u32 clock_gate_inter_e : 1;
> + u32 clock_gate_encoder_h264_e : 1;
> + u32 clock_gate_encoder_h265_e : 1;
> + u32 clock_gate_encoder_e : 1;
> + } swreg3;
> +
> + struct {
> + u32 max_trans_hierarchy_depth_inter : 3;
> + u32 max_trans_hierarchy_depth_intra : 3;
> + u32 sao_enable : 1;
> + u32 active_override_flag : 1;
> + u32 scaling_list_enabled_flag : 1;
> + u32 reserved0 : 2;
> + u32 bw_linebuf_disable : 1;
> + u32 strong_intra_smoothing_enabled_flag : 1;
> + u32 chroma_qp_offset : 5;
> + u32 output_strm_mode : 1;
> + u32 max_trb_size : 2;
> + u32 min_trb_size : 2;
> + u32 max_cb_size : 2;
> + u32 min_cb_size : 2;
> + u32 reserved1 : 2;
> + u32 mode : 3;
> + } swreg4;
> +
> + union {
> + struct {
> + u32 enable : 1;
> + u32 frame_coding_type : 2;
> + u32 ref_frames : 2;
> + u32 buffer_full_continue : 1;
> + u32 output_cu_info_enabled : 1;
> + u32 reserved0 : 1;
> + u32 slice_deblocking_filter_override_flag : 1;
> + u32 pps_deblocking_filter_override_enabled_flag : 1;
> + u32 reserved1 : 1;
> + u32 pic_height : 11;
> + u32 pic_width : 10;
> + } swreg5;
> +
> + struct {
> + u32 reserved : 8;
> + u32 jpeg_pic_height : 12;
> + u32 jpeg_pic_width : 12;
> + } swreg5_jpeg;
> + };
> +
> + struct {
> + u32 cu_qp_delta_enabled : 1;
> + u32 nal_size_write : 1;
> + u32 rps_id : 5;
> + u32 deblocking_beta_offset : 4;
> + u32 deblocking_tc_offset : 4;
> + u32 deblocking_filter_dis : 1;
> + u32 num_positive_pics : 2;
> + u32 num_negative_pics : 2;
> + u32 num_short_term_ref_pic_sets : 5;
> + u32 slice_size : 7;
> + } swreg6;
> +
> + struct {
> + u32 roi2_delta_qp : 4;
> + u32 roi1_delta_qp : 4;
> + u32 pic_qp : 6;
> + u32 diff_cu_qp_delta_depth : 2;
> + u32 reserved : 1;
> + u32 num_slices_ready : 8;
> + u32 cabac_init_flag : 1;
> + u32 pic_init_qp : 6;
> + } swreg7;
> +
> + struct {
> + u32 output_strm_base : 32;
> + } swreg8;
> +
> + struct {
> + u32 output_strm_buffer_limit : 32;
> + } swreg9;
> +
> + struct {
> + u32 size_tbl_base : 32;
> + } swreg10;
> +
> + struct {
> + u32 poc : 32;
> + } swreg11;
> +
> + struct {
> + u32 input_y_base : 32;
> + } swreg12;
> +
> + struct {
> + u32 input_cb_base : 32;
> + } swreg13;
> +
> + struct {
> + u32 input_cr_base : 32;
> + } swreg14;
> +
> + struct {
> + u32 recon_y_base : 32;
> + } swreg15;
> +
> + struct {
> + u32 recon_chroma_base : 32;
> + } swreg16;
> +
> + struct {
> + u32 l0_ref1_chroma_compressor_enable : 1;
> + u32 l0_ref1_luma_compressor_enable : 1;
> + u32 l0_ref0_chroma_compressor_enable : 1;
> + u32 l0_ref0_luma_compressor_enable : 1;
> + u32 recon_chroma_compressor_enable : 1;
> + u32 recon_luma_compressor_enable : 1;
> + u32 active_l0_cnt : 2;
> + u32 l0_used_by_curr_pic1 : 1;
> + u32 l0_long_term_flag1 : 1;
> + u32 l0_delta_poc1 : 10;
> + u32 l0_used_by_curr_pic0 : 1;
> + u32 l0_long_term_flag0 : 1;
> + u32 l0_delta_poc0 : 10;
> + } swreg17;
> +
> + union {
> + struct {
> + u32 refpic_recon_l0_y0 : 32;
> + } swreg18;
> +
> + struct {
> + u32 jpeg_rst : 16;
> + u32 jpeg_rstint : 8;
> + u32 jpeg_mode : 1;
> + u32 jpeg_slice : 1;
> + u32 strm_startoffset : 6;
> + } swreg18_jpeg;
> + };
> +
> + union {
> + struct {
> + u32 refpic_recon_l0_chroma0 : 32;
> + } swreg19;
> +
> + struct {
> + u32 strm_hdrrem1 : 32;
> + } swreg19_jpeg;
> + };
> +
> + union {
> + struct {
> + u32 refpic_recon_l0_y1 : 32;
> + } swreg20;
> +
> + struct {
> + u32 reserved : 8;
> + u32 ljpeg_pt : 3;
> + u32 ljpeg_psv : 3;
> + u32 ljpeg_format : 2;
> + u32 ljpeg_en : 1;
> + u32 jpeg_rowlength : 15;
> + } swreg20_jpeg;
> + };
> +
> + union {
> + struct {
> + u32 refpic_recon_l0_chroma1 : 32;
> + } swreg21;
> +
> + struct {
> + u32 strm_hdrrem2 : 32;
> + } swreg21_jpeg;
> + };
> +
> + struct {
> + u32 roi_area_enable : 1;
> + u32 roi_map_enable : 1;
> + u32 qadj_enable : 1;
> + u32 rc_enable : 1;
> + u32 cir_interval : 14;
> + u32 cir_start : 14;
> + } swreg22;
> +
> + struct {
> + u32 intra_area_bottom : 8;
> + u32 intra_area_top : 8;
> + u32 intra_area_right : 8;
> + u32 intra_area_left : 8;
> + } swreg23;
> +
> + struct {
> + u32 roi1_bottom : 8;
> + u32 roi1_top : 8;
> + u32 roi1_right : 8;
> + u32 roi1_left : 8;
> + } swreg24;
> +
> + struct {
> + u32 roi2_bottom : 8;
> + u32 roi2_top : 8;
> + u32 roi2_right : 8;
> + u32 roi2_left : 8;
> + } swreg25;
> +
> + struct {
> + u32 reserved : 2;
> + u32 intra_size_factor_2 : 10;
> + u32 intra_size_factor_1 : 10;
> + u32 intra_size_factor_0 : 10;
> + } swreg26;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_mode_factor_2 : 7;
> + u32 intra_mode_factor_1 : 6;
> + u32 intra_mode_factor_0 : 5;
> + u32 intra_size_factor_3 : 10;
> + } swreg27;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_1 : 13;
> + u32 lambda_satd_me_0 : 13;
> + } swreg28;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_3 : 13;
> + u32 lambda_satd_me_2 : 13;
> + } swreg29;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_5 : 13;
> + u32 lambda_satd_me_4 : 13;
> + } swreg30;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_7 : 13;
> + u32 lambda_satd_me_6 : 13;
> + } swreg31;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_9 : 13;
> + u32 lambda_satd_me_8 : 13;
> + } swreg32;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_11 : 13;
> + u32 lambda_satd_me_10 : 13;
> + } swreg33;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_13 : 13;
> + u32 lambda_satd_me_12 : 13;
> + } swreg34;
> +
> + struct {
> + u32 bits_est_bias_intra_cu_16 : 8;
> + u32 bits_est_bias_intra_cu_8 : 7;
> + u32 bits_est_tu_split_penalty : 3;
> + u32 lambda_motion_sse : 14;
> + } swreg35;
> +
> + struct {
> + u32 output_bitwidth_chroma : 2;
> + u32 bits_est_1n_cu_penalty : 4;
> + u32 inter_skip_bias : 7;
> + u32 bits_est_bias_intra_cu_64 : 10;
> + u32 bits_est_bias_intra_cu_32 : 9;
> + } swreg36;
> +
> + struct {
> + u32 chroffset : 4;
> + u32 lambda_sao_luma : 14;
> + u32 lambda_sao_chroma : 14;
> + } swreg37;
> +
> + struct {
> + u32 mirror : 1;
> + u32 yfill : 3;
> + u32 xfill : 2;
> + u32 rowlength : 14;
> + u32 lumoffset : 4;
> + u32 output_bitwidth_lum : 2;
> + u32 input_rotation : 2;
> + u32 input_format : 4;
> + } swreg38;
> +
> + struct {
> + u32 rgbcoeffb : 16;
> + u32 rgbcoeffa : 16;
> + } swreg39;
> +
> + struct {
> + u32 rgbcoeffe : 16;
> + u32 rgbcoeffc : 16;
> + } swreg40;
> +
> + struct {
> + u32 reserved : 1;
> + u32 bmaskmsb : 5;
> + u32 gmaskmsb : 5;
> + u32 rmaskmsb : 5;
> + u32 rgbcoefff : 16;
> + } swreg41;
> +
> + struct {
> + u32 basescaledoutlum : 32;
> + } swreg42;
> +
> + struct {
> + u32 scale_mode : 2;
> + u32 scaledoutwidthmsb : 1;
> + u32 scaledoutwidthratio : 16;
> + u32 scaledoutwidth : 13;
> + } swreg43;
> +
> + struct {
> + u32 input_format_msb : 2;
> + u32 scaledoutheightratio : 16;
> + u32 scaledoutheight : 14;
> + } swreg44;
> +
> + struct {
> + u32 reserved : 2;
> + u32 scaledout_format : 1;
> + u32 nalunitsize_swap : 4;
> + u32 scaledverticalcopy : 1;
> + u32 scaledhorizontalcopy : 1;
> + u32 vscale_weight_en : 1;
> + u32 scaledskiptoppixelrow : 2;
> + u32 scaledskipleftpixelcolumn : 2;
> + u32 encoded_ctb_number : 13;
> + u32 chroma_swap : 1;
> + u32 scaledout_swap : 4;
> + } swreg45;
> +
> + struct {
> + u32 compressedcoeff_base : 32;
> + } swreg46;
> +
> + struct {
> + u32 compressedcoeff_base_msb : 32;
> + } swreg47;
> +
> + struct {
> + u32 basescaledoutlum_msb : 32;
> + } swreg48;
> +
> + struct {
> + u32 refpic_recon_l0_y0_msb : 32;
> + } swreg49;
> +
> + struct {
> + u32 refpic_recon_l0_chroma0_msb : 32;
> + } swreg50;
> +
> + struct {
> + u32 refpic_recon_l0_y1_msb : 32;
> + } swreg51;
> +
> + struct {
> + u32 refpic_recon_l0_chroma1_msb : 32;
> + } swreg52;
> +
> + struct {
> + u32 input_y_base_msb : 32;
> + } swreg53;
> +
> + struct {
> + u32 input_cb_base_msb : 32;
> + } swreg54;
> +
> + struct {
> + u32 input_cr_base_msb : 32;
> + } swreg55;
> +
> + struct {
> + u32 recon_y_base_msb : 32;
> + } swreg56;
> +
> + struct {
> + u32 recon_chroma_base_msb : 32;
> + } swreg57;
> +
> + struct {
> + u32 size_tbl_base_msb : 32;
> + } swreg58;
> +
> + struct {
> + u32 output_strm_base_msb : 32;
> + } swreg59;
> +
> + struct {
> + u32 recon_luma_compress_table_base : 32;
> + } swreg60;
> +
> + struct {
> + u32 recon_luma_compress_table_base_msb : 32;
> + } swreg61;
> +
> + struct {
> + u32 recon_chroma_compress_table_base : 32;
> + } swreg62;
> +
> + struct {
> + u32 recon_chroma_compress_table_base_msb : 32;
> + } swreg63;
> +
> + struct {
> + u32 l0_ref0_luma_compress_table_base : 32;
> + } swreg64;
> +
> + struct {
> + u32 l0_ref0_luma_compress_table_base_msb : 32;
> + } swreg65;
> +
> + struct {
> + u32 l0_ref0_chroma_compress_table_base : 32;
> + } swreg66;
> +
> + struct {
> + u32 l0_ref0_chroma_compress_table_base_msb : 32;
> + } swreg67;
> +
> + struct {
> + u32 l0_ref1_luma_compress_table_base : 32;
> + } swreg68;
> +
> + struct {
> + u32 l0_ref1_luma_compress_table_base_msb : 32;
> + } swreg69;
> +
> + struct {
> + u32 l0_ref1_chroma_compress_table_base : 32;
> + } swreg70;
> +
> + struct {
> + u32 l0_ref1_chroma_compress_table_base_msb : 32;
> + } swreg71;
> +
> + struct {
> + u32 recon_luma_4n_base : 32;
> + } swreg72;
> +
> + struct {
> + u32 recon_luma_4n_base_msb : 32;
> + } swreg73;
> +
> + struct {
> + u32 refpic_recon_l0_4n0_base : 32;
> + } swreg74;
> +
> + struct {
> + u32 refpic_recon_l0_4n0_base_msb : 32;
> + } swreg75;
> +
> + struct {
> + u32 refpic_recon_l0_4n1_base : 32;
> + } swreg76;
> +
> + struct {
> + u32 refpic_recon_l0_4n1_base_msb : 32;
> + } swreg77;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_15 : 13;
> + u32 lambda_satd_me_14 : 13;
> + } swreg78;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_0 : 21;
> + } swreg79;
> +
> + struct {
> + u32 hwmaxvideowidth : 13;
> + u32 hwbuswidth : 2;
> + u32 hwjpegsupport : 1;
> + u32 hwtu32support : 1;
> + u32 hwrfcsupport : 1;
> + u32 hwprogrdosupport : 1;
> + u32 hwlinebufsupport : 1;
> + u32 hwcavlcsupport : 1;
> + u32 hwbus : 3;
> + u32 hwmain10support : 1;
> + u32 hwdenoisesupport : 1;
> + u32 hwvp9support : 1;
> + u32 hwhevcsupport : 1;
> + u32 hwrgbsupport : 1;
> + u32 hwbframesupport : 1;
> + u32 hwscalingsupport : 1;
> + u32 hwh264support : 1;
> + } swreg80;
> +
> + struct {
> + u32 timeout_cycles : 23;
> + u32 timeout_override_e : 1;
> + u32 max_burst : 8;
> + } swreg81;
> +
> + struct {
> + u32 hw_performance : 32;
> + } swreg82;
> +
> + struct {
> + u32 refpic_recon_l1_y0 : 32;
> + } swreg83;
> +
> + struct {
> + u32 refpic_recon_l1_chroma0 : 32;
> + } swreg84;
> +
> + struct {
> + u32 refpic_recon_l1_y1 : 32;
> + } swreg85;
> +
> + struct {
> + u32 refpic_recon_l1_chroma1 : 32;
> + } swreg86;
> +
> + struct {
> + u32 refpic_recon_l1_y0_msb : 32;
> + } swreg87;
> +
> + struct {
> + u32 refpic_recon_l1_chroma0_msb : 32;
> + } swreg88;
> +
> + struct {
> + u32 refpic_recon_l1_y1_msb : 32;
> + } swreg89;
> +
> + struct {
> + u32 refpic_recon_l1_chroma1_msb : 32;
> + } swreg90;
> +
> + struct {
> + u32 l1_ref1_chroma_compressor_enable : 1;
> + u32 l1_ref1_luma_compressor_enable : 1;
> + u32 l1_ref0_chroma_compressor_enable : 1;
> + u32 l1_ref0_luma_compressor_enable : 1;
> + u32 long_term_ref_pics_present_flag : 1;
> + u32 reserved : 1;
> + u32 active_l1_cnt : 2;
> + u32 l1_used_by_curr_pic1 : 1;
> + u32 l1_long_term_flag1 : 1;
> + u32 l1_delta_poc1 : 10;
> + u32 l1_used_by_curr_pic0 : 1;
> + u32 l1_long_term_flag0 : 1;
> + u32 l1_delta_poc0 : 10;
> + } swreg91;
> +
> + struct {
> + u32 refpic_recon_l1_4n0_base : 32;
> + } swreg92;
> +
> + struct {
> + u32 refpic_recon_l1_4n0_base_msb : 32;
> + } swreg93;
> +
> + struct {
> + u32 refpic_recon_l1_4n1_base : 32;
> + } swreg94;
> +
> + struct {
> + u32 refpic_recon_l1_4n1_base_msb : 32;
> + } swreg95;
> +
> + struct {
> + u32 l1_ref0_luma_compress_table_base : 32;
> + } swreg96;
> +
> + struct {
> + u32 l1_ref0_luma_compress_table_base_msb : 32;
> + } swreg97;
> +
> + struct {
> + u32 l1_ref0_chroma_compress_table_base : 32;
> + } swreg98;
> +
> + struct {
> + u32 l1_ref0_chroma_compress_table_base_msb : 32;
> + } swreg99;
> +
> + struct {
> + u32 l1_ref1_luma_compress_table_base : 32;
> + } swreg100;
> +
> + struct {
> + u32 l1_ref1_luma_compress_table_base_msb : 32;
> + } swreg101;
> +
> + struct {
> + u32 l1_ref1_chroma_compress_table_base : 32;
> + } swreg102;
> +
> + struct {
> + u32 l1_ref1_chroma_compress_table_base_msb : 32;
> + } swreg103;
> +
> + struct {
> + u32 ref_pic_list_modi_flag_l0 : 1;
> + u32 list_entry_l0_pic0 : 4;
> + u32 list_entry_l0_pic1 : 4;
> + u32 reserved0 : 7;
> + u32 ref_pic_list_modi_flag_l1 : 1;
> + u32 list_entry_l1_pic0 : 4;
> + u32 list_entry_l1_pic1 : 4;
> + u32 reserved1 : 4;
> + u32 rdo_level : 2;
> + u32 lists_modi_present_flag : 1;
> + } swreg104;
> +
> + struct {
> + u32 targetpicsize : 32;
> + } swreg105;
> +
> + struct {
> + u32 minpicsize : 32;
> + } swreg106;
> +
> + struct {
> + u32 maxpicsize : 32;
> + } swreg107;
> +
> + struct {
> + u32 nonzerocount : 24;
> + u32 averageqp : 8;
> + } swreg108;
> +
> + struct {
> + u32 roimapdeltaqpaddr : 32;
> + } swreg109;
> +
> + struct {
> + u32 roimapdeltaqpaddr_msb : 32;
> + } swreg110;
> +
> + struct {
> + u32 reserved : 12;
> + u32 intracu8num : 20;
> + } swreg111;
> +
> + struct {
> + u32 reserved : 12;
> + u32 skipcu8num : 20;
> + } swreg112;
> +
> + struct {
> + u32 pbframe4nrdcost : 32;
> + } swreg113;
> +
> + struct {
> + u32 colctbs_store_base : 32;
> + } swreg114;
> +
> + struct {
> + u32 colctbs_store_base_msb : 32;
> + } swreg115;
> +
> + struct {
> + u32 colctbs_load_base : 32;
> + } swreg116;
> +
> + struct {
> + u32 colctbs_load_base_msb : 32;
> + } swreg117;
> +
> + struct {
> + u32 ctbrcthrdmax : 16;
> + u32 ctbrcthrdmin : 16;
> + } swreg118;
> +
> + struct {
> + u32 ctbbitsmax : 16;
> + u32 ctbbitsmin : 16;
> + } swreg119;
> +
> + struct {
> + u32 totallcubits : 32;
> + } swreg120;
> +
> + struct {
> + u32 bitsratio : 32;
> + } swreg121;
> +
> + union {
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_1 : 21;
> + } swreg122;
> +
> + struct {
> + u32 av1_enable_order_hint : 1;
> + u32 av1_allow_update_cdf : 1;
> + u32 av1_interp_filter : 3;
> + u32 av1_switchable_motion_mode : 1;
> + u32 av1_cur_frame_force_integer_mv : 1;
> + u32 av1_enable_dual_filter : 1;
> + u32 av1_enable_interintra_compound : 1;
> + u32 av1_list1_ref_frame : 4;
> + u32 av1_list0_ref_frame : 4;
> + u32 av1_reference_mode : 2;
> + u32 av1_skip_mode_flag : 1;
> + u32 av1_allow_high_precision_mv : 1;
> + u32 av1_seg_enable : 1;
> + u32 av1_reduced_tx_set_used : 1;
> + u32 av1_tx_mode : 2;
> + u32 av1_enable_filter_intra : 1;
> + u32 av1_delta_q_res : 4;
> + u32 av1_coded_lossless : 1;
> + u32 av1_allow_intrabc : 1;
> + } swreg122_av1;
> + };
> +
> + union {
> + struct {
> + u32 ctbrc_qpdelta_flag_reverse : 1;
> + u32 reserved : 10;
> + u32 lambda_sse_me_2 : 21;
> + } swreg123;
> +
> + struct {
> + u32 reserved : 1;
> + u32 av1_btxtypesearch : 1;
> + u32 av1_primary_ref_frame : 3;
> + u32 av1_sharpness_lvl : 3;
> + u32 av1_db_filter_lvl_v : 6;
> + u32 av1_db_filter_lvl_u : 6;
> + u32 av1_db_filter_lvl1 : 6;
> + u32 av1_db_filter_lvl0 : 6;
> + } swreg123_av1;
> + };
> +
> + union {
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_3 : 21;
> + } swreg124;
> +
> + struct {
> + u32 reserved : 15;
> + u32 av1_cdef_bits : 2;
> + u32 av1_cdef_uv_strengths : 6;
> + u32 av1_cdef_strengths : 6;
> + u32 av1_cdef_damping : 3;
> + } swreg124_av1;
> + };
> +
> + union {
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_1 : 14;
> + u32 intra_satd_lambda_0 : 14;
> + } swreg125;
> +
> + struct {
> + u32 av1_framectx_base : 32;
> + } swreg125_av1;
> + };
> +
> + union {
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_3 : 14;
> + u32 intra_satd_lambda_2 : 14;
> + } swreg126;
> +
> + struct {
> + u32 av1_framectx_base_msb : 32;
> + } swreg126_av1;
> + };
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_5 : 14;
> + u32 intra_satd_lambda_4 : 14;
> + } swreg127;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_7 : 14;
> + u32 intra_satd_lambda_6 : 14;
> + } swreg128;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_9 : 14;
> + u32 intra_satd_lambda_8 : 14;
> + } swreg129;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_11 : 14;
> + u32 intra_satd_lambda_10 : 14;
> + } swreg130;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_13 : 14;
> + u32 intra_satd_lambda_12 : 14;
> + } swreg131;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_15 : 14;
> + u32 intra_satd_lambda_14 : 14;
> + } swreg132;
> +
> + struct {
> + u32 sse_div_256 : 32;
> + } swreg133;
> +
> + struct {
> + u32 nr_mbnum_invert_reg : 16;
> + u32 reserved : 8;
> + u32 noise_low : 6;
> + u32 noise_reduction_enable : 2;
> + } swreg134;
> +
> + struct {
> + u32 reserved : 5;
> + u32 thresh_sigma_cur : 21;
> + u32 sliceqp_prev : 6;
> + } swreg135;
> +
> + struct {
> + u32 frame_sigma_calced : 16;
> + u32 sigma_cur : 16;
> + } swreg136;
> +
> + struct {
> + u32 reserved : 11;
> + u32 thresh_sigma_calced : 21;
> + } swreg137;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_4 : 21;
> + } swreg138;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_5 : 21;
> + } swreg139;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_6 : 21;
> + } swreg140;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_7 : 21;
> + } swreg141;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_8 : 21;
> + } swreg142;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_9 : 21;
> + } swreg143;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_10 : 21;
> + } swreg144;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_11 : 21;
> + } swreg145;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_12 : 21;
> + } swreg146;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_13 : 21;
> + } swreg147;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_14 : 21;
> + } swreg148;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_15 : 21;
> + } swreg149;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_17 : 13;
> + u32 lambda_satd_me_16 : 13;
> + } swreg150;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_19 : 13;
> + u32 lambda_satd_me_18 : 13;
> + } swreg151;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_21 : 13;
> + u32 lambda_satd_me_20 : 13;
> + } swreg152;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_23 : 13;
> + u32 lambda_satd_me_22 : 13;
> + } swreg153;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_25 : 13;
> + u32 lambda_satd_me_24 : 13;
> + } swreg154;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_27 : 13;
> + u32 lambda_satd_me_26 : 13;
> + } swreg155;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_29 : 13;
> + u32 lambda_satd_me_28 : 13;
> + } swreg156;
> +
> + struct {
> + u32 reserved : 6;
> + u32 lambda_satd_me_31 : 13;
> + u32 lambda_satd_me_30 : 13;
> + } swreg157;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_16 : 21;
> + } swreg158;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_17 : 21;
> + } swreg159;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_18 : 21;
> + } swreg160;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_19 : 21;
> + } swreg161;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_20 : 21;
> + } swreg162;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_21 : 21;
> + } swreg163;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_22 : 21;
> + } swreg164;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_23 : 21;
> + } swreg165;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_24 : 21;
> + } swreg166;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_25 : 21;
> + } swreg167;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_26 : 21;
> + } swreg168;
> +
> + struct {
> + u32 reserved : 11;
> + u32 lambda_sse_me_27 : 21;
> + } swreg169;
> +
> + union {
> + struct {
> + u32 roi1_delta_qp_rc : 5;
> + u32 rc_ctbrc_sliceqpoffset : 6;
> + u32 lambda_sse_me_28 : 21;
> + } swreg170_qp_delta;
> +
> + struct {
> + u32 roi1_qp_type : 1;
> + u32 roi1_qp_value : 7;
> + u32 sse_qp_factor : 15;
> + u32 reserved : 8;
> + u32 lambda_depth : 1;
> + } swreg170_qp_absolute;
> + };
> +
> + union {
> + struct {
> + u32 roi2_delta_qp_rc : 5;
> + u32 reserved : 6;
> + u32 lambda_sse_me_29 : 21;
> + } swreg171_qp_delta;
> +
> + struct {
> + u32 roi2_qp_type : 1;
> + u32 roi2_qp_value : 7;
> + u32 sad_qp_factor : 15;
> + u32 reserved : 9;
> + } swreg171_qp_absolute;
> + };
> +
> + struct {
> + u32 complexity_offset : 5;
> + u32 qp_min : 6;
> + u32 lambda_sse_me_30 : 21;
> + } swreg172;
> +
> + struct {
> + u32 rc_qpdelta_range : 4;
> + u32 reserved : 1;
> + u32 qp_max : 6;
> + u32 lambda_sse_me_31 : 21;
> + } swreg173;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_17 : 14;
> + u32 intra_satd_lambda_16 : 14;
> + } swreg174;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_19 : 14;
> + u32 intra_satd_lambda_18 : 14;
> + } swreg175;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_21 : 14;
> + u32 intra_satd_lambda_20 : 14;
> + } swreg176;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_23 : 14;
> + u32 intra_satd_lambda_22 : 14;
> + } swreg177;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_25 : 14;
> + u32 intra_satd_lambda_24 : 14;
> + } swreg178;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_27 : 14;
> + u32 intra_satd_lambda_26 : 14;
> + } swreg179;
> +
> + struct {
> + u32 reserved : 4;
> + u32 intra_satd_lambda_29 : 14;
> + u32 intra_satd_lambda_28 : 14;
> + } swreg180;
> +
> + struct {
> + u32 reserved : 2;
> + u32 rc_block_size : 2;
> + u32 intra_satd_lambda_31 : 14;
> + u32 intra_satd_lambda_30 : 14;
> + } swreg181;
> +
> + struct {
> + u32 qp_delta_gain : 16;
> + u32 qp_fractional : 16;
> + } swreg182;
> +
> + struct {
> + u32 reserved : 6;
> + u32 qp_sum : 26;
> + } swreg183;
> +
> + struct {
> + u32 reserved : 12;
> + u32 qp_num : 20;
> + } swreg184;
> +
> + struct {
> + u32 timeout_cycles_msb : 9;
> + u32 pic_complexity : 23;
> + } swreg185;
> +
> + struct {
> + u32 cu_information_table_base : 32;
> + } swreg186;
> +
> + struct {
> + u32 cu_information_table_base_msb : 32;
> + } swreg187;
> +
> + struct {
> + u32 cu_information_base : 32;
> + } swreg188;
> +
> + struct {
> + u32 cu_information_base_msb : 32;
> + } swreg189;
> +
> + struct {
> + u32 reserved : 30;
> + u32 num_long_term_pics : 2;
> + } swreg190;
> +
> + struct {
> + u32 slice_header_size : 16;
> + u32 prefixnal_svc_ext : 1;
> + u32 pps_id : 6;
> + u32 nuh_temporal_id : 3;
> + u32 nal_unit_type : 6;
> + } swreg191;
> +
> + struct {
> + u32 framenum : 32;
> + } swreg192;
> +
> + struct {
> + u32 entropy_coding_mode : 1;
> + u32 transform8x8_enable : 1;
> + u32 idr_pic_id : 1;
> + u32 nal_ref_idc : 1;
> + u32 yfill_msb : 2;
> + u32 xfill_msb : 2;
> + u32 l0_used_by_next_pic1 : 1;
> + u32 l0_delta_framenum1 : 11;
> + u32 l0_used_by_next_pic0 : 1;
> + u32 l0_delta_framenum0 : 11;
> + } swreg193;
> +
> + struct {
> + u32 reserved : 2;
> + u32 cur_longtermidx : 3;
> + u32 max_longtermidx_plus1 : 3;
> + u32 l1_used_by_next_pic1 : 1;
> + u32 l1_delta_framenum1 : 11;
> + u32 l1_used_by_next_pic0 : 1;
> + u32 l1_delta_framenum0 : 11;
> + } swreg194;
> +
> + struct {
> + u32 reserved : 2;
> + u32 pic_width_msb : 2;
> + u32 roi2_bottom_msb : 1;
> + u32 roi2_top_msb : 1;
> + u32 roi2_right_msb : 1;
> + u32 roi2_left_msb : 1;
> + u32 roi1_bottom_msb : 1;
> + u32 roi1_top_msb : 1;
> + u32 roi1_right_msb : 1;
> + u32 roi1_left_msb : 1;
> + u32 intra_area_bottom_msb : 1;
> + u32 intra_area_top_msb : 1;
> + u32 intra_area_right_msb : 1;
> + u32 intra_area_left_msb : 1;
> + u32 cir_interval_msb : 4;
> + u32 cir_start_msb : 4;
> + u32 slice_size_msb : 2;
> + u32 num_slices_ready_msb : 2;
> + u32 encoded_ctb_number_msb : 4;
> + } swreg195;
> +
> + struct {
> + u32 ctb_row_wr_ptr : 10;
> + u32 ctb_row_rd_ptr : 10;
> + u32 num_ctb_rows_per_sync : 9;
> + u32 input_buf_loopback_en : 1;
> + u32 low_latency_en : 1;
> + u32 low_latency_hw_sync_en : 1;
> + } swreg196;
> +
> + union {
> + struct {
> + u32 reserved : 2;
> + u32 l1_delta_poc0_msb : 10;
> + u32 l0_delta_poc1_msb : 10;
> + u32 l0_delta_poc0_msb : 10;
> + } swreg197;
> +
> + struct {
> + u32 ctb_row_rd_ptr_jpeg_msb : 5;
> + u32 ctb_row_wr_ptr_jpeg_msb : 5;
> + u32 reserved : 22;
> + } swreg197_jpeg;
> + };
> +
> + struct {
> + u32 l1_longtermidx1 : 3;
> + u32 l1_longtermidx0 : 3;
> + u32 l0_longtermidx1 : 3;
> + u32 l0_longtermidx0 : 3;
> + u32 mark_current_longterm : 1;
> + u32 l0_delta_framenum0_msb : 9;
> + u32 l1_delta_poc1_msb : 10;
> + } swreg198;
> +
> + struct {
> + u32 osd_alphablend_enable : 1;
> + u32 hash_offset : 2;
> + u32 hash_type : 2;
> + u32 l1_delta_framenum1_msb : 9;
> + u32 l1_delta_framenum0_msb : 9;
> + u32 l0_delta_framenum1_msb : 9;
> + } swreg199;
> +
> + struct {
> + u32 hash_val : 32;
> + } swreg200;
> +
> + struct {
> + u32 mean_thr3 : 8;
> + u32 mean_thr2 : 8;
> + u32 mean_thr1 : 8;
> + u32 mean_thr0 : 8;
> + } swreg201;
> +
> + struct {
> + u32 thr_dc_chroma_8x8 : 16;
> + u32 thr_dc_lum_8x8 : 16;
> + } swreg202;
> +
> + union {
> + struct {
> + u32 cr_dc_sum_thr : 8;
> + u32 cb_dc_sum_thr : 8;
> + u32 reserved : 8;
> + u32 lum_dc_sum_thr : 8;
> + } swreg203_h264;
> +
> + struct {
> + u32 thr_dc_chroma_16x16 : 16;
> + u32 thr_dc_lum_16x16 : 16;
> + } swreg203_hevc;
> + };
> +
> + struct {
> + u32 thr_dc_chroma_32x32 : 16;
> + u32 thr_dc_lum_32x32 : 16;
> + } swreg204;
> +
> + struct {
> + u32 thr_ac_num_chroma_8x8 : 16;
> + u32 thr_ac_num_lum_8x8 : 16;
> + } swreg205;
> +
> + struct {
> + u32 thr_ac_num_chroma_16x16 : 16;
> + u32 thr_ac_num_lum_16x16 : 16;
> + } swreg206;
> +
> + struct {
> + u32 thr_ac_num_chroma_32x32 : 16;
> + u32 thr_ac_num_lum_32x32 : 16;
> + } swreg207;
> +
> + union {
> + struct {
> + u32 reserved0 : 3;
> + u32 skip_map_enable : 1;
> + u32 ipcm1_left : 9;
> + u32 enable_smart : 1;
> + u32 foreground_pixel_thx : 6;
> + u32 reserved1 : 6;
> + u32 smart_qp : 6;
> + } swreg208_h264;
> +
> + struct {
> + u32 reserved : 3;
> + u32 skip_map_enable : 1;
> + u32 ipcm1_left : 9;
> + u32 enable_smart : 1;
> + u32 foreground_pixel_thx : 6;
> + u32 mdqpc : 6;
> + u32 mdqpy : 6;
> + } swreg208_hevc;
> + };
> +
> + struct {
> + u32 reserved : 3;
> + u32 ipcm_map_enable : 1;
> + u32 pcm_filter_disable : 1;
> + u32 ipcm1_bottom : 9;
> + u32 ipcm1_top : 9;
> + u32 ipcm1_right : 9;
> + } swreg209;
> +
> + struct {
> + u32 reserved : 3;
> + u32 ipcm2_left : 9;
> + u32 input_lu_stride : 20;
> + } swreg210;
> +
> + struct {
> + u32 reserved : 3;
> + u32 ipcm2_right : 9;
> + u32 input_ch_stride : 20;
> + } swreg211;
> +
> + struct {
> + u32 reserved : 3;
> + u32 ipcm2_top : 9;
> + u32 ref_lu_stride : 20;
> + } swreg212;
> +
> + struct {
> + u32 reserved : 5;
> + u32 ipcm2_bottom : 9;
> + u32 ref_ds_lu_stride : 18;
> + } swreg213;
> +
> + struct {
> + u32 hwmaxvideowidthjpeg : 13;
> + u32 hwmaxvideowidthh264 : 13;
> + u32 hwroimapversion : 3;
> + u32 hwintratu32support : 1;
> + u32 hwabsqpsupport : 1;
> + u32 hwljpegsupport : 1;
> + } swreg214;
> +
> + struct {
> + u32 totalarlen : 32;
> + } swreg215;
> +
> + struct {
> + u32 totalr : 32;
> + } swreg216;
> +
> + struct {
> + u32 totalar : 32;
> + } swreg217;
> +
> + struct {
> + u32 totalrlast : 32;
> + } swreg218;
> +
> + struct {
> + u32 totalawlen : 32;
> + } swreg219;
> +
> + struct {
> + u32 totalw : 32;
> + } swreg220;
> +
> + struct {
> + u32 totalaw : 32;
> + } swreg221;
> +
> + struct {
> + u32 totalwlast : 32;
> + } swreg222;
> +
> + struct {
> + u32 totalb : 32;
> + } swreg223;
> +
> + struct {
> + u32 cb_const_pixel : 10;
> + u32 cr_const_pixel : 10;
> + u32 skipframe_en : 1;
> + u32 ssim_en : 1;
> + u32 reserved : 9;
> + u32 chroma_const_en : 1;
> + } swreg224;
> +
> + struct {
> + u32 reserved : 6;
> + u32 roimap_qpdelta_ver : 3;
> + u32 roimap_cuctrl_ver : 3;
> + u32 roimap_cuctrl_enable : 1;
> + u32 roimap_cuctrl_index_enable : 1;
> + u32 loop_filter_across_tiles_enabled_flag : 1;
> + u32 tiles_enabled_flag : 1;
> + u32 num_tile_rows : 8;
> + u32 num_tile_columns : 8;
> + } swreg225;
> +
> + struct {
> + u32 hwdynamicmaxtusize : 1;
> + u32 hwiframeonly : 1;
> + u32 hwstreamsegmentsupport : 1;
> + u32 hwstreambufchain : 1;
> + u32 hwinloopdsratio : 1;
> + u32 hwmultipasssupport : 1;
> + u32 hwrdoqsupport : 1;
> + u32 bframe_me4n_hor_searchrange : 2;
> + u32 hwroi8support : 1;
> + u32 hwgmvsupport : 1;
> + u32 hwjpeg422support : 1;
> + u32 hwctbrcversion : 3;
> + u32 me_vert_searchrange_h264 : 6;
> + u32 me_vert_searchrange_hevc : 6;
> + u32 hwcuinforversion : 3;
> + u32 hwp010refsupport : 1;
> + u32 hwssimsupport : 1;
> + } swreg226;
> +
> + struct {
> + u32 ssim_y_numerator_lsb : 32;
> + } swreg227;
> +
> + struct {
> + u32 ssim_y_numerator_msb : 32;
> + } swreg228;
> +
> + struct {
> + u32 ssim_u_numerator_lsb : 32;
> + } swreg229;
> +
> + struct {
> + u32 ssim_u_numerator_msb : 32;
> + } swreg230;
> +
> + struct {
> + u32 ssim_v_numerator_lsb : 32;
> + } swreg231;
> +
> + struct {
> + u32 ssim_v_numerator_msb : 32;
> + } swreg232;
> +
> + struct {
> + u32 ssim_y_denominator : 32;
> + } swreg233;
> +
> + struct {
> + u32 ssim_uv_denominator : 32;
> + } swreg234;
> +
> + struct {
> + u32 rps_used_by_cur_1 : 1;
> + u32 rps_used_by_cur_0 : 1;
> + u32 rps_delta_poc_2 : 10;
> + u32 rps_delta_poc_1 : 10;
> + u32 rps_delta_poc_0 : 10;
> + } swreg235;
> +
> + struct {
> + u32 reserved : 12;
> + u32 p010_ref_enable : 1;
> + u32 short_term_ref_pic_set_sps_flag : 1;
> + u32 rps_pos_pic_num : 3;
> + u32 rps_neg_pic_num : 3;
> + u32 rps_used_by_cur_3 : 1;
> + u32 rps_used_by_cur_2 : 1;
> + u32 rps_delta_poc_3 : 10;
> + } swreg236;
> +
> + struct {
> + u32 reserved : 11;
> + u32 dummyreaden : 1;
> + u32 ref_ch_stride : 20;
> + } swreg237;
> +
> + struct {
> + u32 dummyreadaddr : 32;
> + } swreg238;
> +
> + struct {
> + u32 current_ctb_mad_base : 32;
> + } swreg239;
> +
> + struct {
> + u32 current_ctb_mad_base_msb : 32;
> + } swreg240;
> +
> + struct {
> + u32 previous_ctb_mad_base : 32;
> + } swreg241;
> +
> + struct {
> + u32 previous_ctb_mad_base_msb : 32;
> + } swreg242;
> +
> + struct {
> + u32 reserved : 11;
> + u32 ctb_rc_model_param0 : 21;
> + } swreg243;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi3_qp_type : 1;
> + u32 roi3_qp_value : 7;
> + u32 ctb_rc_model_param1 : 22;
> + } swreg244;
> +
> + struct {
> + u32 rc_qpdelta_range_msb : 2;
> + u32 ctb_rc_row_factor : 16;
> + u32 ctb_rc_model_param_min : 14;
> + } swreg245;
> +
> + struct {
> + u32 reserved : 3;
> + u32 ctb_rc_delay : 3;
> + u32 axi_write_outstanding_num : 8;
> + u32 ctb_rc_qp_step : 18;
> + } swreg246;
> +
> + struct {
> + u32 reserved0 : 1;
> + u32 ctb_rc_prev_mad_valid : 1;
> + u32 reserved1 : 4;
> + u32 prev_pic_lum_mad : 26;
> + } swreg247;
> +
> + struct {
> + u32 roi4_qp_type : 1;
> + u32 roi4_qp_value : 7;
> + u32 ctb_qp_sum_for_rc : 24;
> + } swreg248;
> +
> + union {
> + struct {
> + u32 reserved : 3;
> + u32 ipcm2_bottom_msb : 1;
> + u32 ipcm2_top_msb : 1;
> + u32 ipcm2_right_msb : 1;
> + u32 ipcm2_left_msb : 1;
> + u32 ipcm1_bottom_msb : 1;
> + u32 ipcm1_top_msb : 1;
> + u32 ipcm1_right_msb : 1;
> + u32 ipcm1_left_msb : 1;
> + u32 pic_width_msb2 : 1;
> + u32 roi2_bottom_msb2 : 1;
> + u32 roi2_top_msb2 : 1;
> + u32 roi2_right_msb2 : 1;
> + u32 roi2_left_msb2 : 1;
> + u32 roi1_bottom_msb2 : 1;
> + u32 roi1_top_msb2 : 1;
> + u32 roi1_right_msb2 : 1;
> + u32 roi1_left_msb2 : 1;
> + u32 intra_area_bottom_msb2 : 1;
> + u32 intra_area_top_msb2 : 1;
> + u32 intra_area_right_msb2 : 1;
> + u32 intra_area_left_msb2 : 1;
> + u32 cir_interval_msb2 : 2;
> + u32 cir_start_msb2 : 2;
> + u32 slice_size_msb2 : 1;
> + u32 num_slices_ready_msb2 : 1;
> + u32 encoded_ctb_number_msb2 : 2;
> + } swreg249;
> +
> + struct {
> + u32 reserved0 : 5;
> + u32 jpeg_rowlength_msb : 2;
> + u32 jpeg_pic_height_msb : 2;
> + u32 jpeg_pic_width_msb : 2;
> + u32 reserved1 : 21;
> + } swreg249_jpeg;
> + };
> +
> + struct {
> + u32 reserved : 4;
> + u32 global_vertical_mv_l0 : 14;
> + u32 global_horizontal_mv_l0 : 14;
> + } swreg250;
> +
> + struct {
> + u32 reserved : 4;
> + u32 global_vertical_mv_l1 : 14;
> + u32 global_horizontal_mv_l1 : 14;
> + } swreg251;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi3_right : 10;
> + u32 roi3_top : 10;
> + u32 roi3_left : 10;
> + } swreg252;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi4_top : 10;
> + u32 roi4_left : 10;
> + u32 roi3_bottom : 10;
> + } swreg253;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi5_left : 10;
> + u32 roi4_bottom : 10;
> + u32 roi4_right : 10;
> + } swreg254;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi5_bottom : 10;
> + u32 roi5_right : 10;
> + u32 roi5_top : 10;
> + } swreg255;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi6_right : 10;
> + u32 roi6_top : 10;
> + u32 roi6_left : 10;
> + } swreg256;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi7_top : 10;
> + u32 roi7_left : 10;
> + u32 roi6_bottom : 10;
> + } swreg257;
> +
> + struct {
> + u32 reserved : 2;
> + u32 roi8_left : 10;
> + u32 roi7_bottom : 10;
> + u32 roi7_right : 10;
> + } swreg258;
> +
> + struct {
> + u32 reserved : 1;
> + u32 current_max_tu_size_decrease : 1;
> + u32 roi8_bottom : 10;
> + u32 roi8_right : 10;
> + u32 roi8_top : 10;
> + } swreg259;
> +
> + struct {
> + u32 roi5_qp_type : 1;
> + u32 roi5_qp_value : 7;
> + u32 roi6_qp_type : 1;
> + u32 roi6_qp_value : 7;
> + u32 roi7_qp_type : 1;
> + u32 roi7_qp_value : 7;
> + u32 roi8_qp_type : 1;
> + u32 roi8_qp_value : 7;
> + } swreg260;
> +
> + struct {
> + u32 motion_score_enable : 1;
> + u32 pass1_skip_cabac : 1;
> + u32 rdoq_enable : 1;
> + u32 multi_core_en : 1;
> + u32 axi_read_outstanding_num : 8;
> + u32 prp_in_loop_ds_ratio : 1;
> + u32 rgblumaoffset : 5;
> + u32 reserved : 14;
> + } swreg261;
> +
> + struct {
> + u32 lum_sse_div_256 : 32;
> + } swreg262;
> +
> + struct {
> + u32 cb_sse_div_64 : 32;
> + } swreg263;
> +
> + struct {
> + u32 cr_sse_div_64 : 32;
> + } swreg264;
> +
> + struct {
> + u32 ddr_polling_interval : 16;
> + u32 ref_ready_threshold : 16;
> + } swreg265;
> +
> + struct {
> + u32 multicore_sync_l0_addr : 32;
> + } swreg266;
> +
> + struct {
> + u32 multicore_sync_l0_addr_msb : 32;
> + } swreg267;
> +
> + struct {
> + u32 multicore_sync_l1_addr : 32;
> + } swreg268;
> +
> + struct {
> + u32 multicore_sync_l1_addr_msb : 32;
> + } swreg269;
> +
> + struct {
> + u32 multicore_sync_rec_addr : 32;
> + } swreg270;
> +
> + struct {
> + u32 multicore_sync_rec_addr_msb : 32;
> + } swreg271;
> +
> + struct {
> + u32 wr_urgent_disable_threshold : 8;
> + u32 wr_urgent_enable_threshold : 8;
> + u32 rd_urgent_disable_threshold : 8;
> + u32 rd_urgent_enable_threshold : 8;
> + } swreg272;
> +
> + struct {
> + u32 roimap_cuctrl_index_addr : 32;
> + } swreg273;
> +
> + struct {
> + u32 roimap_cuctrl_index_addr_msb : 32;
> + } swreg274;
> +
> + struct {
> + u32 roimap_cuctrl_addr : 32;
> + } swreg275;
> +
> + struct {
> + u32 roimap_cuctrl_addr_msb : 32;
> + } swreg276;
> +
> + struct {
> + u32 reserved : 5;
> + u32 syn_amount_per_loopback : 15;
> + u32 pic_order_cnt_type : 2;
> + u32 log2_max_frame_num : 5;
> + u32 log2_max_pic_order_cnt_lsb : 5;
> + } swreg277;
> +
> + struct {
> + u32 output_strm_buf1_base : 32;
> + } swreg278;
> +
> + struct {
> + u32 output_strm_buf1_base_msb : 32;
> + } swreg279;
> +
> + struct {
> + u32 output_strm_buffer1_limit : 32;
> + } swreg280;
> +
> + struct {
> + u32 reserved : 2;
> + u32 chroma_format_idc : 2;
> + u32 num_ctb_rows_per_sync_msb : 6;
> + u32 strm_segment_wr_ptr : 10;
> + u32 strm_segment_rd_ptr : 10;
> + u32 strm_segment_en : 1;
> + u32 strm_segment_sw_sync_en : 1;
> + } swreg281;
> +
> + struct {
> + u32 strm_segment_size : 32;
> + } swreg282;
> +
> + struct {
> + u32 motion_score_l0_0 : 32;
> + } swreg283;
> +
> + struct {
> + u32 motion_score_l0_1 : 32;
> + } swreg284;
> +
> + struct {
> + u32 motion_score_l1_0 : 32;
> + } swreg285;
> +
> + struct {
> + u32 motion_score_l1_1 : 32;
> + } swreg286;
> +
> + struct {
> + u32 reserved0 : 21;
> + u32 hwmonochromesupport : 1;
> + u32 hwmevertrangeprogramable : 1;
> + u32 hwctbrcmoremode : 1;
> + u32 reserved1 : 4;
> + u32 hwcutreesupport : 1;
> + u32 hwscaler420support : 1;
> + u32 hwcscextensionsupport : 1;
> + u32 hwvideoheightext : 1;
> + } swreg287;
> +
> + struct {
> + u32 reserved : 12;
> + u32 cuinfoversion : 3;
> + u32 ctb_qp_sum_for_rc_msb : 2;
> + u32 pic_complexity_msb : 4;
> + u32 qp_num_msb : 3;
> + u32 qp_sum_msb : 2;
> + u32 skipcu8num_msb : 3;
> + u32 intracu8num_msb : 3;
> + } swreg288;
> +
> + struct {
> + u32 rgbcoeffh : 16;
> + u32 rgbcoeffg : 16;
> + } swreg289;
> +
> + struct {
> + u32 totalarlen2 : 32;
> + } swreg290;
> +
> + struct {
> + u32 totalr2 : 32;
> + } swreg291;
> +
> + struct {
> + u32 totalar2 : 32;
> + } swreg292;
> +
> + struct {
> + u32 totalrlast2 : 32;
> + } swreg293;
> +
> + struct {
> + u32 totalawlen2 : 32;
> + } swreg294;
> +
> + struct {
> + u32 totalw2 : 32;
> + } swreg295;
> +
> + struct {
> + u32 totalaw2 : 32;
> + } swreg296;
> +
> + struct {
> + u32 totalwlast2 : 32;
> + } swreg297;
> +
> + struct {
> + u32 totalb2 : 32;
> + } swreg298;
> +
> + struct {
> + u32 ext_sram_lum_fwd_base : 32;
> + } swreg299;
> +
> + struct {
> + u32 ext_sram_lum_fwd_base_msb : 32;
> + } swreg300;
> +
> + struct {
> + u32 ext_sram_lum_bwd_base : 32;
> + } swreg301;
> +
> + struct {
> + u32 ext_sram_lum_bwd_base_msb : 32;
> + } swreg302;
> +
> + struct {
> + u32 ext_sram_chr_fwd_base : 32;
> + } swreg303;
> +
> + struct {
> + u32 ext_sram_chr_fwd_base_msb : 32;
> + } swreg304;
> +
> + struct {
> + u32 ext_sram_chr_bwd_base : 32;
> + } swreg305;
> +
> + struct {
> + u32 ext_sram_chr_bwd_base_msb : 32;
> + } swreg306;
> +
> + struct {
> + u32 extlinebuffer_linecnt_chr_bwd : 8;
> + u32 extlinebuffer_linecnt_chr_fwd : 8;
> + u32 extlinebuffer_linecnt_lum_bwd : 8;
> + u32 extlinebuffer_linecnt_lum_fwd : 8;
> + } swreg307;
> +
> + struct {
> + u32 axi_strm_write_pending : 32;
> + } swreg308;
> +
> + struct {
> + u32 axi_recon_write_pending : 32;
> + } swreg309;
> +
> + struct {
> + u32 axi_rec4n_write_pending : 32;
> + } swreg310;
> +
> + struct {
> + u32 axi_prp_read_pending : 32;
> + } swreg311;
> +
> + struct {
> + u32 axi_ref_read_pending : 32;
> + } swreg312;
> +
> + struct {
> + u32 axi_ref4n_read_pending : 32;
> + } swreg313;
> +
> + struct {
> + u32 axi_rcroi_read_pending : 32;
> + } swreg314;
> +
> + struct {
> + u32 axi_read_channel_pending : 32;
> + } swreg315;
> +
> + struct {
> + u32 axi_write_channel_pending : 32;
> + } swreg316;
> +
> + struct {
> + u32 axi_total_pending : 32;
> + } swreg317;
> +
> + struct {
> + u32 hw_debug : 32;
> + } swreg318;
> +
> + struct {
> + u32 axi_burst_align_fuse_rd_lu_ref_prefetch : 4;
> + u32 axi_burst_align_fuse_rd_ch_ref_prefetch : 4;
> + u32 axi_burst_align_fuse_rd_prp : 4;
> + u32 axi_burst_align_fuse_rd_common : 4;
> + u32 axi_burst_align_fuse_wr_luma_ref : 4;
> + u32 axi_burst_align_fuse_wr_chroma_ref : 4;
> + u32 axi_burst_align_fuse_wr_stream : 4;
> + u32 axi_burst_align_fuse_wr_common : 4;
> + } swreg319;
> +
> + struct {
> + u32 axi_burst_align_rd_lu_ref_prefetch : 4;
> + u32 axi_burst_align_rd_ch_ref_prefetch : 4;
> + u32 axi_burst_align_rd_prp : 4;
> + u32 axi_burst_align_rd_common : 4;
> + u32 axi_burst_align_wr_luma_ref : 4;
> + u32 axi_burst_align_wr_chroma_ref : 4;
> + u32 axi_burst_align_wr_stream : 4;
> + u32 axi_burst_align_wr_common : 4;
> + } swreg320;
> +
> + struct {
> + u32 reserved : 26;
> + u32 me_assigned_vert_search_range : 6;
> + } swreg321;
> +} __packed;
> +
> +#endif /* HANTRO_VC8000E_REGS_H_ */
[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
next prev parent reply other threads:[~2026-11-17 22:00 UTC|newest]
Thread overview: 36+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-05-22 10:16 [PATCH 00/14] media: Add V4L2 H.264 stateless encode and VC8000E support Paul Kocialkowski
2026-05-22 10:16 ` [PATCH 01/14] media: h264: Add a more generic reflist builder init Paul Kocialkowski
2026-11-17 21:06 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 02/14] media: uapi: Add H.264 stateless encode support Paul Kocialkowski
2026-11-17 21:30 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 03/14] media: h264: Add SPS video definitions Paul Kocialkowski
2026-11-17 21:31 ` Nicolas Dufresne
2026-11-17 21:34 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 04/14] media: h264: Add stateless encode core Paul Kocialkowski
2026-11-17 21:37 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 05/14] media: h264: Add stateless encode rbsp Paul Kocialkowski
2026-05-22 10:16 ` [PATCH 06/14] media: h264: Add stateless encode reference management Paul Kocialkowski
2026-05-22 10:16 ` [PATCH 07/14] media: h264: Add stateless encode rate control Paul Kocialkowski
2026-05-22 10:16 ` [PATCH 08/14] media: verisilicon: Report default pixel coding for non-JPEG and fix JPEG case Paul Kocialkowski
2026-05-22 10:16 ` [PATCH 09/14] media: verisilicon: Cancel job with runtime pm put/clk disable on failure Paul Kocialkowski
2026-11-17 21:42 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 10/14] media: hantro: use hantro_decoded_buffer only for dst_vq Paul Kocialkowski
2026-11-17 21:48 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 11/14] media: verisilicon: Add common encoder parm and frameintervals ioctls Paul Kocialkowski
2026-11-17 21:50 ` Nicolas Dufresne
2026-05-22 10:16 ` [PATCH 12/14] media: verisilicon: Add support for the VC8000E H.264 encoder Paul Kocialkowski
2026-11-17 22:00 ` Nicolas Dufresne [this message]
2026-05-22 10:16 ` [PATCH 13/14] media: verilisicon: imx8m: Add support for the VC8000E on i.MX8MP Paul Kocialkowski
2026-05-22 10:16 ` [PATCH 14/14] arm64: dts: imx8mp: add VC8000E encoder node Paul Kocialkowski
2026-05-22 11:28 ` Fabio Estevam
2026-11-17 22:02 ` Nicolas Dufresne
2026-05-22 14:47 ` [PATCH 00/14] media: Add V4L2 H.264 stateless encode and VC8000E support Nicolas Dufresne
2026-09-23 12:10 ` Michael Nazzareno Trimarchi
2026-09-23 20:05 ` Paul Kocialkowski
2026-09-24 5:30 ` Michael Nazzareno Trimarchi
2026-09-24 18:09 ` Paul Kocialkowski
2026-09-24 19:38 ` Michael Nazzareno Trimarchi
2026-09-24 19:44 ` Nicolas Dufresne
2026-09-24 20:30 ` Paul Kocialkowski
2026-09-24 20:46 ` Nicolas Dufresne
2026-09-30 4:14 ` Chen-Yu Tsai
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=206d0fb68342892f1e007ff7299dd07edc65e80a.camel@collabora.com \
--to=nicolas.dufresne@collabora.com \
--cc=benjamin.gaignard@collabora.com \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=hverkuil@kernel.org \
--cc=imx@lists.linux.dev \
--cc=kernel@pengutronix.de \
--cc=krzk+dt@kernel.org \
--cc=linux-arm-kernel@lists.infradead.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-media@vger.kernel.org \
--cc=m.felsch@pengutronix.de \
--cc=m.tretter@pengutronix.de \
--cc=mchehab@kernel.org \
--cc=p.zabel@pengutronix.de \
--cc=paulk@sys-base.io \
--cc=robh@kernel.org \
--cc=s.hauer@pengutronix.de \
--cc=shawnguo@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox