Linux Media Controller development
 help / color / mirror / Atom feed
* [PATCH v2 0/9] v4l2: Add tracing for stateless codecs
@ 2026-06-10 14:33 Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 1/9] media: Move visl traces to v4l2-core Detlev Casanova
                   ` (9 more replies)
  0 siblings, 10 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

Hi !

This patchset aims to improve codec event tracing in v4l2.

The traces added in visl by Daniel Almeida are moved to the global trace
events.
They are adapted to trace each each field separately and not just the
whole struct so that userspace can filter on different fields and
libraries like libtracefs and libtraceevent can be used to list the
fields instead of parsing the trace printk's.

The trace event templates are also reworked to avoid long lines, but
quoted string splits are kept as they don't cut words.

To each trace event are also added a tgid and fd fields, helping
userspace track different decoding sessions (contexts) based on the given
file descriptor used by the given process id.

Also for better tracking, stream on and stream off events are added as
well as HW run and HW done events to track decoder core usage.

The main focus is to be able to generate perfetto traces to show VPU usage,
a perfetto producer using this can be found at [1] (it will be renamed to
match the more generic approach than hantro).
Other controls can be traced later as well, this patch set only focuses on
mem2mem type drivers.

[1]:
https://gitlab.collabora.com/detlev/hantro-perf/-/tree/hantro-improved-info

Changes since v1:
- Don't modify the printk format
- Trace all fields of the structs instead of the whole struct as a buffer
- Remove fdinfo patches (they will come in another patch set)
- Fix long lines
- Rename v4l2_requests.h trace header to v4l2_controls.h
- Add basic documentation

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
Detlev Casanova (9):
      media: Move visl traces to v4l2-core
      media: Map each struct field to its own trace field
      media: Add tgid and fd fields in v4l2_fh struct
      media: Add tgid and fd to the v4l2-requests trace fields
      media: Add missing types to v4l2_ctrl_ptr
      media: Trace the stateless controls when set in v4l2-ctrls-core.c
      media: Add stream on/off traces and run them in the ioctl
      media: Add HW run/done trace events
      media: hantro: Add v4l2_hw run/done traces

 drivers/media/platform/verisilicon/hantro.h        |    1 +
 drivers/media/platform/verisilicon/hantro_drv.c    |   10 +
 .../platform/verisilicon/rockchip_vpu981_regs.h    |    1 +
 .../media/platform/verisilicon/rockchip_vpu_hw.c   |    4 +
 drivers/media/test-drivers/visl/Makefile           |    2 +-
 drivers/media/test-drivers/visl/visl-dec.c         |   76 -
 drivers/media/test-drivers/visl/visl-trace-av1.h   |  314 ---
 drivers/media/test-drivers/visl/visl-trace-fwht.h  |   66 -
 drivers/media/test-drivers/visl/visl-trace-h264.h  |  349 ---
 drivers/media/test-drivers/visl/visl-trace-hevc.h  |  464 ----
 drivers/media/test-drivers/visl/visl-trace-mpeg2.h |   99 -
 .../media/test-drivers/visl/visl-trace-points.c    |   11 -
 drivers/media/test-drivers/visl/visl-trace-vp8.h   |  156 --
 drivers/media/test-drivers/visl/visl-trace-vp9.h   |  292 ---
 drivers/media/v4l2-core/v4l2-ctrls-api.c           |   10 +
 drivers/media/v4l2-core/v4l2-ctrls-core.c          |  114 +
 drivers/media/v4l2-core/v4l2-fh.c                  |    1 +
 drivers/media/v4l2-core/v4l2-ioctl.c               |   37 +-
 drivers/media/v4l2-core/v4l2-trace.c               |   48 +
 include/media/v4l2-ctrls.h                         |   19 +
 include/media/v4l2-fh.h                            |    4 +
 include/trace/events/v4l2.h                        |   77 +
 include/trace/events/v4l2_controls.h               | 2708 ++++++++++++++++++++
 23 files changed, 3033 insertions(+), 1830 deletions(-)
---
base-commit: acb7500801e98639f6d8c2d796ed9f64cba83d3a
change-id: 20260608-v4l2-add-ftrace-aec6e7f60a6c

Best regards,
--  
Detlev Casanova <detlev.casanova@collabora.com>


^ permalink raw reply	[flat|nested] 11+ messages in thread

* [PATCH v2 1/9] media: Move visl traces to v4l2-core
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 2/9] media: Map each struct field to its own trace field Detlev Casanova
                   ` (8 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

The visl driver defines traces for all stateless controls.
Move those definition to a new v4l2_requests.h file and expose them for
all drivers to use.

As each event can be enabled individually in userspace, group them all in
the same v4l2_requests event folder.

Later, it can also be used by v4l2-core to trace controls as they are
being set.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 drivers/media/test-drivers/visl/Makefile           |    2 +-
 drivers/media/test-drivers/visl/visl-dec.c         |    8 +-
 drivers/media/test-drivers/visl/visl-trace-av1.h   |  314 ----
 drivers/media/test-drivers/visl/visl-trace-fwht.h  |   66 -
 drivers/media/test-drivers/visl/visl-trace-h264.h  |  349 -----
 drivers/media/test-drivers/visl/visl-trace-hevc.h  |  464 ------
 drivers/media/test-drivers/visl/visl-trace-mpeg2.h |   99 --
 .../media/test-drivers/visl/visl-trace-points.c    |   11 -
 drivers/media/test-drivers/visl/visl-trace-vp8.h   |  156 --
 drivers/media/test-drivers/visl/visl-trace-vp9.h   |  292 ----
 drivers/media/v4l2-core/v4l2-trace.c               |   45 +
 include/trace/events/v4l2_controls.h               | 1645 ++++++++++++++++++++
 12 files changed, 1692 insertions(+), 1759 deletions(-)

diff --git a/drivers/media/test-drivers/visl/Makefile b/drivers/media/test-drivers/visl/Makefile
index fb4d5ae1b17f..a5049e2af844 100644
--- a/drivers/media/test-drivers/visl/Makefile
+++ b/drivers/media/test-drivers/visl/Makefile
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0+
-visl-y := visl-core.o visl-video.o visl-dec.o visl-trace-points.o
+visl-y := visl-core.o visl-video.o visl-dec.o
 
 ifeq ($(CONFIG_VISL_DEBUGFS),y)
   visl-y += visl-debugfs.o
diff --git a/drivers/media/test-drivers/visl/visl-dec.c b/drivers/media/test-drivers/visl/visl-dec.c
index 6bbf93757047..1c66a1b8d78f 100644
--- a/drivers/media/test-drivers/visl/visl-dec.c
+++ b/drivers/media/test-drivers/visl/visl-dec.c
@@ -7,18 +7,12 @@
 #include "visl.h"
 #include "visl-debugfs.h"
 #include "visl-dec.h"
-#include "visl-trace-fwht.h"
-#include "visl-trace-mpeg2.h"
-#include "visl-trace-vp8.h"
-#include "visl-trace-vp9.h"
-#include "visl-trace-h264.h"
-#include "visl-trace-hevc.h"
-#include "visl-trace-av1.h"
 
 #include <linux/delay.h>
 #include <linux/workqueue.h>
 #include <media/v4l2-mem2mem.h>
 #include <media/tpg/v4l2-tpg.h>
+#include <trace/events/v4l2_controls.h>
 
 #define LAST_BUF_IDX (V4L2_AV1_REF_LAST_FRAME - V4L2_AV1_REF_LAST_FRAME)
 #define LAST2_BUF_IDX (V4L2_AV1_REF_LAST2_FRAME - V4L2_AV1_REF_LAST_FRAME)
diff --git a/drivers/media/test-drivers/visl/visl-trace-av1.h b/drivers/media/test-drivers/visl/visl-trace-av1.h
deleted file mode 100644
index 09f205de53df..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-av1.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_AV1_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_AV1_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_av1_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
-	TP_fast_assign(__entry->s = *s;),
-	TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
-		  "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
-		  __print_flags(__entry->s.flags, "|",
-		  {V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
-		  {V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA, "ENABLE_FILTER_INTRA"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER, "ENABLE_INTRA_EDGE_FILTER"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND, "ENABLE_INTERINTRA_COMPOUND"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND, "ENABLE_MASKED_COMPOUND"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION, "ENABLE_WARPED_MOTION"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER, "ENABLE_DUAL_FILTER"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT, "ENABLE_ORDER_HINT"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP, "ENABLE_JNT_COMP"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS, "ENABLE_REF_FRAME_MVS"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES, "ENABLE_SUPERRES"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF, "ENABLE_CDEF"},
-		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION, "ENABLE_RESTORATION"},
-		  {V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME, "MONO_CHROME"},
-		  {V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE, "COLOR_RANGE"},
-		  {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X, "SUBSAMPLING_X"},
-		  {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y, "SUBSAMPLING_Y"},
-		  {V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT, "FILM_GRAIN_PARAMS_PRESENT"},
-		  {V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q, "SEPARATE_UV_DELTA_Q"}),
-		  __entry->s.seq_profile,
-		  __entry->s.order_hint_bits,
-		  __entry->s.bit_depth,
-		  __entry->s.max_frame_width_minus_1,
-		  __entry->s.max_frame_height_minus_1
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
-	TP_ARGS(t),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
-	TP_fast_assign(__entry->t = *t;),
-	TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
-		  __entry->t.tile_offset,
-		  __entry->t.tile_size,
-		  __entry->t.tile_row,
-		  __entry->t.tile_col
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
-	TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
-		  "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
-		  "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
-		  "tile_info.width_in_sbs_minus_1: %s\ntile_info.height_in_sbs_minus_1: %s\n"
-		  "tile_info.tile_size_bytes: %u\nquantization.flags: %s\n"
-		  "quantization.base_q_idx: %u\nquantization.delta_q_y_dc: %d\n"
-		  "quantization.delta_q_u_dc: %d\nquantization.delta_q_u_ac: %d\n"
-		  "quantization.delta_q_v_dc: %d\nquantization.delta_q_v_ac: %d\n"
-		  "quantization.qm_y: %u\nquantization.qm_u: %u\nquantization.qm_v: %u\n"
-		  "quantization.delta_q_res: %u\nsuperres_denom: %u\nsegmentation.flags: %s\n"
-		  "segmentation.last_active_seg_id: %u\nsegmentation.feature_enabled:%s\n"
-		  "loop_filter.flags: %s\nloop_filter.level: %s\nloop_filter.sharpness: %u\n"
-		  "loop_filter.ref_deltas: %s\nloop_filter.mode_deltas: %s\n"
-		  "loop_filter.delta_lf_res: %u\ncdef.damping_minus_3: %u\ncdef.bits: %u\n"
-		  "cdef.y_pri_strength: %s\ncdef.y_sec_strength: %s\n"
-		  "cdef.uv_pri_strength: %s\ncdef.uv_sec_strength:%s\nskip_mode_frame: %s\n"
-		  "primary_ref_frame: %u\nloop_restoration.flags: %s\n"
-		  "loop_restoration.lr_unit_shift: %u\nloop_restoration.lr_uv_shift: %u\n"
-		  "loop_restoration.frame_restoration_type: %s\n"
-		  "loop_restoration.loop_restoration_size: %s\nflags: %s\norder_hint: %u\n"
-		  "upscaled_width: %u\nframe_width_minus_1: %u\nframe_height_minus_1: %u\n"
-		  "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
-		  "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
-		  "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
-		  __print_flags(__entry->f.tile_info.flags, "|",
-		  {V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
-		  __entry->f.tile_info.context_update_tile_id,
-		  __entry->f.tile_info.tile_cols,
-		  __entry->f.tile_info.tile_rows,
-		  __print_array(__entry->f.tile_info.mi_col_starts,
-				ARRAY_SIZE(__entry->f.tile_info.mi_col_starts),
-				sizeof(__entry->f.tile_info.mi_col_starts[0])),
-		  __print_array(__entry->f.tile_info.mi_row_starts,
-				ARRAY_SIZE(__entry->f.tile_info.mi_row_starts),
-				sizeof(__entry->f.tile_info.mi_row_starts[0])),
-		  __print_array(__entry->f.tile_info.width_in_sbs_minus_1,
-				ARRAY_SIZE(__entry->f.tile_info.width_in_sbs_minus_1),
-				sizeof(__entry->f.tile_info.width_in_sbs_minus_1[0])),
-		  __print_array(__entry->f.tile_info.height_in_sbs_minus_1,
-				ARRAY_SIZE(__entry->f.tile_info.height_in_sbs_minus_1),
-				sizeof(__entry->f.tile_info.height_in_sbs_minus_1[0])),
-		  __entry->f.tile_info.tile_size_bytes,
-		  __print_flags(__entry->f.quantization.flags, "|",
-		  {V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA, "DIFF_UV_DELTA"},
-		  {V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX, "USING_QMATRIX"},
-		  {V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT, "DELTA_Q_PRESENT"}),
-		  __entry->f.quantization.base_q_idx,
-		  __entry->f.quantization.delta_q_y_dc,
-		  __entry->f.quantization.delta_q_u_dc,
-		  __entry->f.quantization.delta_q_u_ac,
-		  __entry->f.quantization.delta_q_v_dc,
-		  __entry->f.quantization.delta_q_v_ac,
-		  __entry->f.quantization.qm_y,
-		  __entry->f.quantization.qm_u,
-		  __entry->f.quantization.qm_v,
-		  __entry->f.quantization.delta_q_res,
-		  __entry->f.superres_denom,
-		  __print_flags(__entry->f.segmentation.flags, "|",
-		  {V4L2_AV1_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
-		  {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
-		  {V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
-		  {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
-		  {V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP, "SEG_ID_PRE_SKIP"}),
-		  __entry->f.segmentation.last_active_seg_id,
-		  __print_array(__entry->f.segmentation.feature_enabled,
-				ARRAY_SIZE(__entry->f.segmentation.feature_enabled),
-				sizeof(__entry->f.segmentation.feature_enabled[0])),
-		  __print_flags(__entry->f.loop_filter.flags, "|",
-		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
-		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"},
-		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT, "DELTA_LF_PRESENT"},
-		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI, "DELTA_LF_MULTI"}),
-		  __print_array(__entry->f.loop_filter.level,
-				ARRAY_SIZE(__entry->f.loop_filter.level),
-				sizeof(__entry->f.loop_filter.level[0])),
-		  __entry->f.loop_filter.sharpness,
-		  __print_array(__entry->f.loop_filter.ref_deltas,
-				ARRAY_SIZE(__entry->f.loop_filter.ref_deltas),
-				sizeof(__entry->f.loop_filter.ref_deltas[0])),
-		  __print_array(__entry->f.loop_filter.mode_deltas,
-				ARRAY_SIZE(__entry->f.loop_filter.mode_deltas),
-				sizeof(__entry->f.loop_filter.mode_deltas[0])),
-		  __entry->f.loop_filter.delta_lf_res,
-		  __entry->f.cdef.damping_minus_3,
-		  __entry->f.cdef.bits,
-		  __print_array(__entry->f.cdef.y_pri_strength,
-				ARRAY_SIZE(__entry->f.cdef.y_pri_strength),
-				sizeof(__entry->f.cdef.y_pri_strength[0])),
-		  __print_array(__entry->f.cdef.y_sec_strength,
-				ARRAY_SIZE(__entry->f.cdef.y_sec_strength),
-				sizeof(__entry->f.cdef.y_sec_strength[0])),
-		  __print_array(__entry->f.cdef.uv_pri_strength,
-				ARRAY_SIZE(__entry->f.cdef.uv_pri_strength),
-				sizeof(__entry->f.cdef.uv_pri_strength[0])),
-		  __print_array(__entry->f.cdef.uv_sec_strength,
-				ARRAY_SIZE(__entry->f.cdef.uv_sec_strength),
-				sizeof(__entry->f.cdef.uv_sec_strength[0])),
-		  __print_array(__entry->f.skip_mode_frame,
-				ARRAY_SIZE(__entry->f.skip_mode_frame),
-				sizeof(__entry->f.skip_mode_frame[0])),
-		  __entry->f.primary_ref_frame,
-		  __print_flags(__entry->f.loop_restoration.flags, "|",
-		  {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR, "USES_LR"},
-		  {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR, "USES_CHROMA_LR"}),
-		  __entry->f.loop_restoration.lr_unit_shift,
-		  __entry->f.loop_restoration.lr_uv_shift,
-		  __print_array(__entry->f.loop_restoration.frame_restoration_type,
-				ARRAY_SIZE(__entry->f.loop_restoration.frame_restoration_type),
-				sizeof(__entry->f.loop_restoration.frame_restoration_type[0])),
-		  __print_array(__entry->f.loop_restoration.loop_restoration_size,
-				ARRAY_SIZE(__entry->f.loop_restoration.loop_restoration_size),
-				sizeof(__entry->f.loop_restoration.loop_restoration_size[0])),
-		  __print_flags(__entry->f.flags, "|",
-		  {V4L2_AV1_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
-		  {V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME, "SHOWABLE_FRAME"},
-		  {V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE, "ERROR_RESILIENT_MODE"},
-		  {V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE, "DISABLE_CDF_UPDATE"},
-		  {V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS, "ALLOW_SCREEN_CONTENT_TOOLS"},
-		  {V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV, "FORCE_INTEGER_MV"},
-		  {V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC, "ALLOW_INTRABC"},
-		  {V4L2_AV1_FRAME_FLAG_USE_SUPERRES, "USE_SUPERRES"},
-		  {V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV, "ALLOW_HIGH_PRECISION_MV"},
-		  {V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE, "IS_MOTION_MODE_SWITCHABLE"},
-		  {V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS, "USE_REF_FRAME_MVS"},
-		  {V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF,
-		   "DISABLE_FRAME_END_UPDATE_CDF"},
-		  {V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION, "ALLOW_WARPED_MOTION"},
-		  {V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT, "REFERENCE_SELECT"},
-		  {V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET, "REDUCED_TX_SET"},
-		  {V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED, "SKIP_MODE_ALLOWED"},
-		  {V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT, "SKIP_MODE_PRESENT"},
-		  {V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE, "FRAME_SIZE_OVERRIDE"},
-		  {V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT, "BUFFER_REMOVAL_TIME_PRESENT"},
-		  {V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING, "FRAME_REFS_SHORT_SIGNALING"}),
-		  __entry->f.order_hint,
-		  __entry->f.upscaled_width,
-		  __entry->f.frame_width_minus_1,
-		  __entry->f.frame_height_minus_1,
-		  __entry->f.render_width_minus_1,
-		  __entry->f.render_height_minus_1,
-		  __entry->f.current_frame_id,
-		  __print_array(__entry->f.buffer_removal_time,
-				ARRAY_SIZE(__entry->f.buffer_removal_time),
-				sizeof(__entry->f.buffer_removal_time[0])),
-		  __print_array(__entry->f.order_hints,
-				ARRAY_SIZE(__entry->f.order_hints),
-				sizeof(__entry->f.order_hints[0])),
-		  __print_array(__entry->f.reference_frame_ts,
-				ARRAY_SIZE(__entry->f.reference_frame_ts),
-				sizeof(__entry->f.reference_frame_ts[0])),
-		  __print_array(__entry->f.ref_frame_idx,
-				ARRAY_SIZE(__entry->f.ref_frame_idx),
-				sizeof(__entry->f.ref_frame_idx[0])),
-		  __entry->f.refresh_frame_flags
-	)
-);
-
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
-	TP_fast_assign(__entry->f = *f;),
-	TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
-		  "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
-		  "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
-		  "point_cb_scaling: %s\nnum_cr_points: %u\npoint_cr_value: %s\n"
-		  "point_cr_scaling: %s\ngrain_scaling_minus_8: %u\nar_coeff_lag: %u\n"
-		  "ar_coeffs_y_plus_128: %s\nar_coeffs_cb_plus_128: %s\n"
-		  "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
-		  "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
-		  "cb_offset: %u\ncr_offset: %u\n",
-		  __print_flags(__entry->f.flags, "|",
-		  {V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
-		  {V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
-		  {V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA, "CHROMA_SCALING_FROM_LUMA"},
-		  {V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP, "OVERLAP"},
-		  {V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE, "CLIP_TO_RESTRICTED_RANGE"}),
-		  __entry->f.cr_mult,
-		  __entry->f.grain_seed,
-		  __entry->f.film_grain_params_ref_idx,
-		  __entry->f.num_y_points,
-		  __print_array(__entry->f.point_y_value,
-				ARRAY_SIZE(__entry->f.point_y_value),
-				sizeof(__entry->f.point_y_value[0])),
-		  __print_array(__entry->f.point_y_scaling,
-				ARRAY_SIZE(__entry->f.point_y_scaling),
-				sizeof(__entry->f.point_y_scaling[0])),
-		  __entry->f.num_cb_points,
-		  __print_array(__entry->f.point_cb_value,
-				ARRAY_SIZE(__entry->f.point_cb_value),
-				sizeof(__entry->f.point_cb_value[0])),
-		  __print_array(__entry->f.point_cb_scaling,
-				ARRAY_SIZE(__entry->f.point_cb_scaling),
-				sizeof(__entry->f.point_cb_scaling[0])),
-		  __entry->f.num_cr_points,
-		  __print_array(__entry->f.point_cr_value,
-				ARRAY_SIZE(__entry->f.point_cr_value),
-				sizeof(__entry->f.point_cr_value[0])),
-		  __print_array(__entry->f.point_cr_scaling,
-				ARRAY_SIZE(__entry->f.point_cr_scaling),
-				sizeof(__entry->f.point_cr_scaling[0])),
-		  __entry->f.grain_scaling_minus_8,
-		  __entry->f.ar_coeff_lag,
-		  __print_array(__entry->f.ar_coeffs_y_plus_128,
-				ARRAY_SIZE(__entry->f.ar_coeffs_y_plus_128),
-				sizeof(__entry->f.ar_coeffs_y_plus_128[0])),
-		  __print_array(__entry->f.ar_coeffs_cb_plus_128,
-				ARRAY_SIZE(__entry->f.ar_coeffs_cb_plus_128),
-				sizeof(__entry->f.ar_coeffs_cb_plus_128[0])),
-		  __print_array(__entry->f.ar_coeffs_cr_plus_128,
-				ARRAY_SIZE(__entry->f.ar_coeffs_cr_plus_128),
-				sizeof(__entry->f.ar_coeffs_cr_plus_128[0])),
-		  __entry->f.ar_coeff_shift_minus_6,
-		  __entry->f.grain_scale_shift,
-		  __entry->f.cb_mult,
-		  __entry->f.cb_luma_mult,
-		  __entry->f.cr_luma_mult,
-		  __entry->f.cb_offset,
-		  __entry->f.cr_offset
-	)
-)
-
-DEFINE_EVENT(v4l2_ctrl_av1_seq_tmpl, v4l2_ctrl_av1_sequence,
-	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_av1_frame_tmpl, v4l2_ctrl_av1_frame,
-	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
-	TP_ARGS(f)
-);
-
-DEFINE_EVENT(v4l2_ctrl_av1_tge_tmpl, v4l2_ctrl_av1_tile_group_entry,
-	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
-	TP_ARGS(t)
-);
-
-DEFINE_EVENT(v4l2_ctrl_av1_film_grain_tmpl, v4l2_ctrl_av1_film_grain,
-	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
-	TP_ARGS(f)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-av1
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-fwht.h b/drivers/media/test-drivers/visl/visl-trace-fwht.h
deleted file mode 100644
index 54b119359ff5..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-fwht.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_FWHT_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_FWHT_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_fwht_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(
-			 __field(u64, backward_ref_ts)
-			 __field(u32, version)
-			 __field(u32, width)
-			 __field(u32, height)
-			 __field(u32, flags)
-			 __field(u32, colorspace)
-			 __field(u32, xfer_func)
-			 __field(u32, ycbcr_enc)
-			 __field(u32, quantization)
-			 ),
-	TP_fast_assign(
-		       __entry->backward_ref_ts = p->backward_ref_ts;
-		       __entry->version = p->version;
-		       __entry->width = p->width;
-		       __entry->height = p->height;
-		       __entry->flags = p->flags;
-		       __entry->colorspace = p->colorspace;
-		       __entry->xfer_func = p->xfer_func;
-		       __entry->ycbcr_enc = p->ycbcr_enc;
-		       __entry->quantization = p->quantization;
-		       ),
-	TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u xfer_func %u ycbcr_enc %u quantization %u",
-		  __entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
-		  __print_flags(__entry->flags, "|",
-		  {V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
-		  {V4L2_FWHT_FL_IS_BOTTOM_FIRST, "IS_BOTTOM_FIRST"},
-		  {V4L2_FWHT_FL_IS_ALTERNATE, "IS_ALTERNATE"},
-		  {V4L2_FWHT_FL_IS_BOTTOM_FIELD, "IS_BOTTOM_FIELD"},
-		  {V4L2_FWHT_FL_LUMA_IS_UNCOMPRESSED, "LUMA_IS_UNCOMPRESSED"},
-		  {V4L2_FWHT_FL_CB_IS_UNCOMPRESSED, "CB_IS_UNCOMPRESSED"},
-		  {V4L2_FWHT_FL_CR_IS_UNCOMPRESSED, "CR_IS_UNCOMPRESSED"},
-		  {V4L2_FWHT_FL_ALPHA_IS_UNCOMPRESSED, "ALPHA_IS_UNCOMPRESSED"},
-		  {V4L2_FWHT_FL_I_FRAME, "I_FRAME"},
-		  {V4L2_FWHT_FL_PIXENC_HSV, "PIXENC_HSV"},
-		  {V4L2_FWHT_FL_PIXENC_RGB, "PIXENC_RGB"},
-		  {V4L2_FWHT_FL_PIXENC_YUV, "PIXENC_YUV"}),
-		  __entry->colorspace, __entry->xfer_func, __entry->ycbcr_enc,
-		  __entry->quantization)
-);
-
-DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
-	TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
-	TP_ARGS(p)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-fwht
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-h264.h b/drivers/media/test-drivers/visl/visl-trace-h264.h
deleted file mode 100644
index d84296a01deb..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-h264.h
+++ /dev/null
@@ -1,349 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_H264_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_H264_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_h264_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
-	TP_fast_assign(__entry->s = *s),
-	TP_printk("\nprofile_idc %u\n"
-		  "constraint_set_flags %s\n"
-		  "level_idc %u\n"
-		  "seq_parameter_set_id %u\n"
-		  "chroma_format_idc %u\n"
-		  "bit_depth_luma_minus8 %u\n"
-		  "bit_depth_chroma_minus8 %u\n"
-		  "log2_max_frame_num_minus4 %u\n"
-		  "pic_order_cnt_type %u\n"
-		  "log2_max_pic_order_cnt_lsb_minus4 %u\n"
-		  "max_num_ref_frames %u\n"
-		  "num_ref_frames_in_pic_order_cnt_cycle %u\n"
-		  "offset_for_ref_frame %s\n"
-		  "offset_for_non_ref_pic %d\n"
-		  "offset_for_top_to_bottom_field %d\n"
-		  "pic_width_in_mbs_minus1 %u\n"
-		  "pic_height_in_map_units_minus1 %u\n"
-		  "flags %s",
-		  __entry->s.profile_idc,
-		  __print_flags(__entry->s.constraint_set_flags, "|",
-		  {V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
-		  {V4L2_H264_SPS_CONSTRAINT_SET1_FLAG, "CONSTRAINT_SET1_FLAG"},
-		  {V4L2_H264_SPS_CONSTRAINT_SET2_FLAG, "CONSTRAINT_SET2_FLAG"},
-		  {V4L2_H264_SPS_CONSTRAINT_SET3_FLAG, "CONSTRAINT_SET3_FLAG"},
-		  {V4L2_H264_SPS_CONSTRAINT_SET4_FLAG, "CONSTRAINT_SET4_FLAG"},
-		  {V4L2_H264_SPS_CONSTRAINT_SET5_FLAG, "CONSTRAINT_SET5_FLAG"}),
-		  __entry->s.level_idc,
-		  __entry->s.seq_parameter_set_id,
-		  __entry->s.chroma_format_idc,
-		  __entry->s.bit_depth_luma_minus8,
-		  __entry->s.bit_depth_chroma_minus8,
-		  __entry->s.log2_max_frame_num_minus4,
-		  __entry->s.pic_order_cnt_type,
-		  __entry->s.log2_max_pic_order_cnt_lsb_minus4,
-		  __entry->s.max_num_ref_frames,
-		  __entry->s.num_ref_frames_in_pic_order_cnt_cycle,
-		  __print_array(__entry->s.offset_for_ref_frame,
-				ARRAY_SIZE(__entry->s.offset_for_ref_frame),
-				sizeof(__entry->s.offset_for_ref_frame[0])),
-		  __entry->s.offset_for_non_ref_pic,
-		  __entry->s.offset_for_top_to_bottom_field,
-		  __entry->s.pic_width_in_mbs_minus1,
-		  __entry->s.pic_height_in_map_units_minus1,
-		  __print_flags(__entry->s.flags, "|",
-		  {V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
-		  {V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS, "QPPRIME_Y_ZERO_TRANSFORM_BYPASS"},
-		  {V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO, "DELTA_PIC_ORDER_ALWAYS_ZERO"},
-		  {V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED, "GAPS_IN_FRAME_NUM_VALUE_ALLOWED"},
-		  {V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY, "FRAME_MBS_ONLY"},
-		  {V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD, "MB_ADAPTIVE_FRAME_FIELD"},
-		  {V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE, "DIRECT_8X8_INFERENCE"}
-		  ))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
-	TP_fast_assign(__entry->p = *p),
-	TP_printk("\npic_parameter_set_id %u\n"
-		  "seq_parameter_set_id %u\n"
-		  "num_slice_groups_minus1 %u\n"
-		  "num_ref_idx_l0_default_active_minus1 %u\n"
-		  "num_ref_idx_l1_default_active_minus1 %u\n"
-		  "weighted_bipred_idc %u\n"
-		  "pic_init_qp_minus26 %d\n"
-		  "pic_init_qs_minus26 %d\n"
-		  "chroma_qp_index_offset %d\n"
-		  "second_chroma_qp_index_offset %d\n"
-		  "flags %s",
-		  __entry->p.pic_parameter_set_id,
-		  __entry->p.seq_parameter_set_id,
-		  __entry->p.num_slice_groups_minus1,
-		  __entry->p.num_ref_idx_l0_default_active_minus1,
-		  __entry->p.num_ref_idx_l1_default_active_minus1,
-		  __entry->p.weighted_bipred_idc,
-		  __entry->p.pic_init_qp_minus26,
-		  __entry->p.pic_init_qs_minus26,
-		  __entry->p.chroma_qp_index_offset,
-		  __entry->p.second_chroma_qp_index_offset,
-		  __print_flags(__entry->p.flags, "|",
-		  {V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE, "ENTROPY_CODING_MODE"},
-		  {V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT, "BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT"},
-		  {V4L2_H264_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
-		  {V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
-		  {V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
-		  {V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT, "REDUNDANT_PIC_CNT_PRESENT"},
-		  {V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE, "TRANSFORM_8X8_MODE"},
-		  {V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT, "SCALING_MATRIX_PRESENT"}
-		  ))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
-	TP_fast_assign(__entry->s = *s),
-	TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_4x4,
-				   sizeof(__entry->s.scaling_list_4x4),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_8x8,
-				   sizeof(__entry->s.scaling_list_8x8),
-				   false)
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
-	TP_fast_assign(__entry->p = *p),
-	TP_printk("\nluma_log2_weight_denom %u\n"
-		  "chroma_log2_weight_denom %u\n"
-		  "weight_factor[0].luma_weight %s\n"
-		  "weight_factor[0].luma_offset %s\n"
-		  "weight_factor[0].chroma_weight {%s}\n"
-		  "weight_factor[0].chroma_offset {%s}\n"
-		  "weight_factor[1].luma_weight %s\n"
-		  "weight_factor[1].luma_offset %s\n"
-		  "weight_factor[1].chroma_weight {%s}\n"
-		  "weight_factor[1].chroma_offset {%s}\n",
-		  __entry->p.luma_log2_weight_denom,
-		  __entry->p.chroma_log2_weight_denom,
-		  __print_array(__entry->p.weight_factors[0].luma_weight,
-				ARRAY_SIZE(__entry->p.weight_factors[0].luma_weight),
-				sizeof(__entry->p.weight_factors[0].luma_weight[0])),
-		  __print_array(__entry->p.weight_factors[0].luma_offset,
-				ARRAY_SIZE(__entry->p.weight_factors[0].luma_offset),
-				sizeof(__entry->p.weight_factors[0].luma_offset[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[0].chroma_weight,
-				   sizeof(__entry->p.weight_factors[0].chroma_weight),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[0].chroma_offset,
-				   sizeof(__entry->p.weight_factors[0].chroma_offset),
-				   false),
-		  __print_array(__entry->p.weight_factors[1].luma_weight,
-				ARRAY_SIZE(__entry->p.weight_factors[1].luma_weight),
-				sizeof(__entry->p.weight_factors[1].luma_weight[0])),
-		  __print_array(__entry->p.weight_factors[1].luma_offset,
-				ARRAY_SIZE(__entry->p.weight_factors[1].luma_offset),
-				sizeof(__entry->p.weight_factors[1].luma_offset[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[1].chroma_weight,
-				   sizeof(__entry->p.weight_factors[1].chroma_weight),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[1].chroma_offset,
-				   sizeof(__entry->p.weight_factors[1].chroma_offset),
-				   false)
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
-	TP_fast_assign(__entry->s = *s),
-	TP_printk("\nheader_bit_size %u\n"
-		  "first_mb_in_slice %u\n"
-		  "slice_type %s\n"
-		  "colour_plane_id %u\n"
-		  "redundant_pic_cnt %u\n"
-		  "cabac_init_idc %u\n"
-		  "slice_qp_delta %d\n"
-		  "slice_qs_delta %d\n"
-		  "disable_deblocking_filter_idc %u\n"
-		  "slice_alpha_c0_offset_div2 %u\n"
-		  "slice_beta_offset_div2 %u\n"
-		  "num_ref_idx_l0_active_minus1 %u\n"
-		  "num_ref_idx_l1_active_minus1 %u\n"
-		  "flags %s",
-		  __entry->s.header_bit_size,
-		  __entry->s.first_mb_in_slice,
-		  __print_symbolic(__entry->s.slice_type,
-		  {V4L2_H264_SLICE_TYPE_P, "P"},
-		  {V4L2_H264_SLICE_TYPE_B, "B"},
-		  {V4L2_H264_SLICE_TYPE_I, "I"},
-		  {V4L2_H264_SLICE_TYPE_SP, "SP"},
-		  {V4L2_H264_SLICE_TYPE_SI, "SI"}),
-		  __entry->s.colour_plane_id,
-		  __entry->s.redundant_pic_cnt,
-		  __entry->s.cabac_init_idc,
-		  __entry->s.slice_qp_delta,
-		  __entry->s.slice_qs_delta,
-		  __entry->s.disable_deblocking_filter_idc,
-		  __entry->s.slice_alpha_c0_offset_div2,
-		  __entry->s.slice_beta_offset_div2,
-		  __entry->s.num_ref_idx_l0_active_minus1,
-		  __entry->s.num_ref_idx_l1_active_minus1,
-		  __print_flags(__entry->s.flags, "|",
-		  {V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED, "DIRECT_SPATIAL_MV_PRED"},
-		  {V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH, "SP_FOR_SWITCH"})
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
-	TP_PROTO(const struct v4l2_h264_reference *r, int i),
-	TP_ARGS(r, i),
-	TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
-			 __field(int, i)),
-	TP_fast_assign(__entry->r = *r; __entry->i = i;),
-	TP_printk("[%d]: fields %s index %u",
-		  __entry->i,
-		  __print_flags(__entry->r.fields, "|",
-		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
-		  {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
-		  {V4L2_H264_FRAME_REF, "FRAME_REF"}),
-		  __entry->r.index
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
-	TP_ARGS(d),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
-	TP_fast_assign(__entry->d = *d),
-	TP_printk("\nnal_ref_idc %u\n"
-		  "frame_num %u\n"
-		  "top_field_order_cnt %d\n"
-		  "bottom_field_order_cnt %d\n"
-		  "idr_pic_id %u\n"
-		  "pic_order_cnt_lsb %u\n"
-		  "delta_pic_order_cnt_bottom %d\n"
-		  "delta_pic_order_cnt0 %d\n"
-		  "delta_pic_order_cnt1 %d\n"
-		  "dec_ref_pic_marking_bit_size %u\n"
-		  "pic_order_cnt_bit_size %u\n"
-		  "slice_group_change_cycle %u\n"
-		  "flags %s\n",
-		  __entry->d.nal_ref_idc,
-		  __entry->d.frame_num,
-		  __entry->d.top_field_order_cnt,
-		  __entry->d.bottom_field_order_cnt,
-		  __entry->d.idr_pic_id,
-		  __entry->d.pic_order_cnt_lsb,
-		  __entry->d.delta_pic_order_cnt_bottom,
-		  __entry->d.delta_pic_order_cnt0,
-		  __entry->d.delta_pic_order_cnt1,
-		  __entry->d.dec_ref_pic_marking_bit_size,
-		  __entry->d.pic_order_cnt_bit_size,
-		  __entry->d.slice_group_change_cycle,
-		  __print_flags(__entry->d.flags, "|",
-		  {V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
-		  {V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC, "FIELD_PIC"},
-		  {V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD, "BOTTOM_FIELD"},
-		  {V4L2_H264_DECODE_PARAM_FLAG_PFRAME, "PFRAME"},
-		  {V4L2_H264_DECODE_PARAM_FLAG_BFRAME, "BFRAME"})
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
-	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
-	TP_ARGS(e, i),
-	TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
-			 __field(int, i)),
-	TP_fast_assign(__entry->e = *e; __entry->i = i;),
-	TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
-		  "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
-		  __entry->i,
-		  __entry->e.reference_ts,
-		  __entry->e.pic_num,
-		  __entry->e.frame_num,
-		  __print_flags(__entry->e.fields, "|",
-		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
-		  {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
-		  {V4L2_H264_FRAME_REF, "FRAME_REF"}),
-		  __entry->e.top_field_order_cnt,
-		  __entry->e.bottom_field_order_cnt,
-		  __print_flags(__entry->e.flags, "|",
-		  {V4L2_H264_DPB_ENTRY_FLAG_VALID, "VALID"},
-		  {V4L2_H264_DPB_ENTRY_FLAG_ACTIVE, "ACTIVE"},
-		  {V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM, "LONG_TERM"},
-		  {V4L2_H264_DPB_ENTRY_FLAG_FIELD, "FIELD"})
-
-	)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_sps_tmpl, v4l2_ctrl_h264_sps,
-	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_pps_tmpl, v4l2_ctrl_h264_pps,
-	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
-	TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_scaling_matrix_tmpl, v4l2_ctrl_h264_scaling_matrix,
-	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_pred_weights_tmpl, v4l2_ctrl_h264_pred_weights,
-	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
-	TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_slice_params_tmpl, v4l2_ctrl_h264_slice_params,
-	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list0,
-	TP_PROTO(const struct v4l2_h264_reference *r, int i),
-	TP_ARGS(r, i)
-);
-
-DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list1,
-	TP_PROTO(const struct v4l2_h264_reference *r, int i),
-	TP_ARGS(r, i)
-);
-
-DEFINE_EVENT(v4l2_ctrl_h264_decode_params_tmpl, v4l2_ctrl_h264_decode_params,
-	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
-	TP_ARGS(d)
-);
-
-DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
-	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
-	TP_ARGS(e, i)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-h264
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-hevc.h b/drivers/media/test-drivers/visl/visl-trace-hevc.h
deleted file mode 100644
index 963914c463db..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-hevc.h
+++ /dev/null
@@ -1,464 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0+ */
-#include "linux/v4l2-controls.h"
-#if !defined(_VISL_TRACE_HEVC_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_HEVC_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_hevc_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
-	TP_fast_assign(__entry->s = *s),
-	TP_printk("\nvideo_parameter_set_id %u\n"
-		  "seq_parameter_set_id %u\n"
-		  "pic_width_in_luma_samples %u\n"
-		  "pic_height_in_luma_samples %u\n"
-		  "bit_depth_luma_minus8 %u\n"
-		  "bit_depth_chroma_minus8 %u\n"
-		  "log2_max_pic_order_cnt_lsb_minus4 %u\n"
-		  "sps_max_dec_pic_buffering_minus1 %u\n"
-		  "sps_max_num_reorder_pics %u\n"
-		  "sps_max_latency_increase_plus1 %u\n"
-		  "log2_min_luma_coding_block_size_minus3 %u\n"
-		  "log2_diff_max_min_luma_coding_block_size %u\n"
-		  "log2_min_luma_transform_block_size_minus2 %u\n"
-		  "log2_diff_max_min_luma_transform_block_size %u\n"
-		  "max_transform_hierarchy_depth_inter %u\n"
-		  "max_transform_hierarchy_depth_intra %u\n"
-		  "pcm_sample_bit_depth_luma_minus1 %u\n"
-		  "pcm_sample_bit_depth_chroma_minus1 %u\n"
-		  "log2_min_pcm_luma_coding_block_size_minus3 %u\n"
-		  "log2_diff_max_min_pcm_luma_coding_block_size %u\n"
-		  "num_short_term_ref_pic_sets %u\n"
-		  "num_long_term_ref_pics_sps %u\n"
-		  "chroma_format_idc %u\n"
-		  "sps_max_sub_layers_minus1 %u\n"
-		  "flags %s",
-		  __entry->s.video_parameter_set_id,
-		  __entry->s.seq_parameter_set_id,
-		  __entry->s.pic_width_in_luma_samples,
-		  __entry->s.pic_height_in_luma_samples,
-		  __entry->s.bit_depth_luma_minus8,
-		  __entry->s.bit_depth_chroma_minus8,
-		  __entry->s.log2_max_pic_order_cnt_lsb_minus4,
-		  __entry->s.sps_max_dec_pic_buffering_minus1,
-		  __entry->s.sps_max_num_reorder_pics,
-		  __entry->s.sps_max_latency_increase_plus1,
-		  __entry->s.log2_min_luma_coding_block_size_minus3,
-		  __entry->s.log2_diff_max_min_luma_coding_block_size,
-		  __entry->s.log2_min_luma_transform_block_size_minus2,
-		  __entry->s.log2_diff_max_min_luma_transform_block_size,
-		  __entry->s.max_transform_hierarchy_depth_inter,
-		  __entry->s.max_transform_hierarchy_depth_intra,
-		  __entry->s.pcm_sample_bit_depth_luma_minus1,
-		  __entry->s.pcm_sample_bit_depth_chroma_minus1,
-		  __entry->s.log2_min_pcm_luma_coding_block_size_minus3,
-		  __entry->s.log2_diff_max_min_pcm_luma_coding_block_size,
-		  __entry->s.num_short_term_ref_pic_sets,
-		  __entry->s.num_long_term_ref_pics_sps,
-		  __entry->s.chroma_format_idc,
-		  __entry->s.sps_max_sub_layers_minus1,
-		  __print_flags(__entry->s.flags, "|",
-		  {V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
-		  {V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED, "SCALING_LIST_ENABLED"},
-		  {V4L2_HEVC_SPS_FLAG_AMP_ENABLED, "AMP_ENABLED"},
-		  {V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET, "SAMPLE_ADAPTIVE_OFFSET"},
-		  {V4L2_HEVC_SPS_FLAG_PCM_ENABLED, "PCM_ENABLED"},
-		  {V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED, "V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED"},
-		  {V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT, "LONG_TERM_REF_PICS_PRESENT"},
-		  {V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED, "TEMPORAL_MVP_ENABLED"},
-		  {V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED, "STRONG_INTRA_SMOOTHING_ENABLED"}
-	))
-
-);
-
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
-	TP_fast_assign(__entry->p = *p),
-	TP_printk("\npic_parameter_set_id %u\n"
-		  "num_extra_slice_header_bits %u\n"
-		  "num_ref_idx_l0_default_active_minus1 %u\n"
-		  "num_ref_idx_l1_default_active_minus1 %u\n"
-		  "init_qp_minus26 %d\n"
-		  "diff_cu_qp_delta_depth %u\n"
-		  "pps_cb_qp_offset %d\n"
-		  "pps_cr_qp_offset %d\n"
-		  "num_tile_columns_minus1 %d\n"
-		  "num_tile_rows_minus1 %d\n"
-		  "column_width_minus1 %s\n"
-		  "row_height_minus1 %s\n"
-		  "pps_beta_offset_div2 %d\n"
-		  "pps_tc_offset_div2 %d\n"
-		  "log2_parallel_merge_level_minus2 %u\n"
-		  "flags %s",
-		  __entry->p.pic_parameter_set_id,
-		  __entry->p.num_extra_slice_header_bits,
-		  __entry->p.num_ref_idx_l0_default_active_minus1,
-		  __entry->p.num_ref_idx_l1_default_active_minus1,
-		  __entry->p.init_qp_minus26,
-		  __entry->p.diff_cu_qp_delta_depth,
-		  __entry->p.pps_cb_qp_offset,
-		  __entry->p.pps_cr_qp_offset,
-		  __entry->p.num_tile_columns_minus1,
-		  __entry->p.num_tile_rows_minus1,
-		  __print_array(__entry->p.column_width_minus1,
-				ARRAY_SIZE(__entry->p.column_width_minus1),
-				sizeof(__entry->p.column_width_minus1[0])),
-		  __print_array(__entry->p.row_height_minus1,
-				ARRAY_SIZE(__entry->p.row_height_minus1),
-				sizeof(__entry->p.row_height_minus1[0])),
-		  __entry->p.pps_beta_offset_div2,
-		  __entry->p.pps_tc_offset_div2,
-		  __entry->p.log2_parallel_merge_level_minus2,
-		  __print_flags(__entry->p.flags, "|",
-		  {V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED, "DEPENDENT_SLICE_SEGMENT_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT, "OUTPUT_FLAG_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED, "SIGN_DATA_HIDING_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT, "CABAC_INIT_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
-		  {V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED, "CU_QP_DELTA_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT, "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
-		  {V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED, "WEIGHTED_BIPRED"},
-		  {V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED, "TRANSQUANT_BYPASS_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_TILES_ENABLED, "TILES_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED, "ENTROPY_CODING_SYNC_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED, "LOOP_FILTER_ACROSS_TILES_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED, "PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED, "DEBLOCKING_FILTER_OVERRIDE_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER, "DISABLE_DEBLOCKING_FILTER"},
-		  {V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT, "LISTS_MODIFICATION_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT, "SLICE_SEGMENT_HEADER_EXTENSION_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_UNIFORM_SPACING, "UNIFORM_SPACING"}
-	))
-
-);
-
-
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
-	TP_fast_assign(__entry->s = *s),
-	TP_printk("\nbit_size %u\n"
-		  "data_byte_offset %u\n"
-		  "num_entry_point_offsets %u\n"
-		  "nal_unit_type %u\n"
-		  "nuh_temporal_id_plus1 %u\n"
-		  "slice_type %u\n"
-		  "colour_plane_id %u\n"
-		  "slice_pic_order_cnt %d\n"
-		  "num_ref_idx_l0_active_minus1 %u\n"
-		  "num_ref_idx_l1_active_minus1 %u\n"
-		  "collocated_ref_idx %u\n"
-		  "five_minus_max_num_merge_cand %u\n"
-		  "slice_qp_delta %d\n"
-		  "slice_cb_qp_offset %d\n"
-		  "slice_cr_qp_offset %d\n"
-		  "slice_act_y_qp_offset %d\n"
-		  "slice_act_cb_qp_offset %d\n"
-		  "slice_act_cr_qp_offset %d\n"
-		  "slice_beta_offset_div2 %d\n"
-		  "slice_tc_offset_div2 %d\n"
-		  "pic_struct %u\n"
-		  "slice_segment_addr %u\n"
-		  "ref_idx_l0 %s\n"
-		  "ref_idx_l1 %s\n"
-		  "short_term_ref_pic_set_size %u\n"
-		  "long_term_ref_pic_set_size %u\n"
-		  "flags %s",
-		  __entry->s.bit_size,
-		  __entry->s.data_byte_offset,
-		  __entry->s.num_entry_point_offsets,
-		  __entry->s.nal_unit_type,
-		  __entry->s.nuh_temporal_id_plus1,
-		  __entry->s.slice_type,
-		  __entry->s.colour_plane_id,
-		  __entry->s.slice_pic_order_cnt,
-		  __entry->s.num_ref_idx_l0_active_minus1,
-		  __entry->s.num_ref_idx_l1_active_minus1,
-		  __entry->s.collocated_ref_idx,
-		  __entry->s.five_minus_max_num_merge_cand,
-		  __entry->s.slice_qp_delta,
-		  __entry->s.slice_cb_qp_offset,
-		  __entry->s.slice_cr_qp_offset,
-		  __entry->s.slice_act_y_qp_offset,
-		  __entry->s.slice_act_cb_qp_offset,
-		  __entry->s.slice_act_cr_qp_offset,
-		  __entry->s.slice_beta_offset_div2,
-		  __entry->s.slice_tc_offset_div2,
-		  __entry->s.pic_struct,
-		  __entry->s.slice_segment_addr,
-		  __print_array(__entry->s.ref_idx_l0,
-				ARRAY_SIZE(__entry->s.ref_idx_l0),
-				sizeof(__entry->s.ref_idx_l0[0])),
-		  __print_array(__entry->s.ref_idx_l1,
-				ARRAY_SIZE(__entry->s.ref_idx_l1),
-				sizeof(__entry->s.ref_idx_l1[0])),
-		  __entry->s.short_term_ref_pic_set_size,
-		  __entry->s.long_term_ref_pic_set_size,
-		  __print_flags(__entry->s.flags, "|",
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA, "SLICE_SAO_LUMA"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA, "SLICE_SAO_CHROMA"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED, "SLICE_TEMPORAL_MVP_ENABLED"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO, "MVD_L1_ZERO"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT, "CABAC_INIT"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0, "COLLOCATED_FROM_L0"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV, "USE_INTEGER_MV"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED, "SLICE_DEBLOCKING_FILTER_DISABLED"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED, "SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENT, "DEPENDENT_SLICE_SEGMENT"}
-
-	))
-);
-
-DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
-	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
-	TP_fast_assign(__entry->p = *p),
-	TP_printk("\ndelta_luma_weight_l0 %s\n"
-		  "luma_offset_l0 %s\n"
-		  "delta_chroma_weight_l0 {%s}\n"
-		  "chroma_offset_l0 {%s}\n"
-		  "delta_luma_weight_l1 %s\n"
-		  "luma_offset_l1 %s\n"
-		  "delta_chroma_weight_l1 {%s}\n"
-		  "chroma_offset_l1 {%s}\n"
-		  "luma_log2_weight_denom %d\n"
-		  "delta_chroma_log2_weight_denom %d\n",
-		  __print_array(__entry->p.delta_luma_weight_l0,
-				ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
-				sizeof(__entry->p.delta_luma_weight_l0[0])),
-		  __print_array(__entry->p.luma_offset_l0,
-				ARRAY_SIZE(__entry->p.luma_offset_l0),
-				sizeof(__entry->p.luma_offset_l0[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.delta_chroma_weight_l0,
-				   sizeof(__entry->p.delta_chroma_weight_l0),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.chroma_offset_l0,
-				   sizeof(__entry->p.chroma_offset_l0),
-				   false),
-		  __print_array(__entry->p.delta_luma_weight_l1,
-				ARRAY_SIZE(__entry->p.delta_luma_weight_l1),
-				sizeof(__entry->p.delta_luma_weight_l1[0])),
-		  __print_array(__entry->p.luma_offset_l1,
-				ARRAY_SIZE(__entry->p.luma_offset_l1),
-				sizeof(__entry->p.luma_offset_l1[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.delta_chroma_weight_l1,
-				   sizeof(__entry->p.delta_chroma_weight_l1),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.chroma_offset_l1,
-				   sizeof(__entry->p.chroma_offset_l1),
-				   false),
-		__entry->p.luma_log2_weight_denom,
-		__entry->p.delta_chroma_log2_weight_denom
-
-	))
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
-	TP_fast_assign(__entry->s = *s),
-	TP_printk("\nscaling_list_4x4 {%s}\n"
-		  "scaling_list_8x8 {%s}\n"
-		  "scaling_list_16x16 {%s}\n"
-		  "scaling_list_32x32 {%s}\n"
-		  "scaling_list_dc_coef_16x16 %s\n"
-		  "scaling_list_dc_coef_32x32 %s\n",
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_4x4,
-				   sizeof(__entry->s.scaling_list_4x4),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_8x8,
-				   sizeof(__entry->s.scaling_list_8x8),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_16x16,
-				   sizeof(__entry->s.scaling_list_16x16),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_32x32,
-				   sizeof(__entry->s.scaling_list_32x32),
-				   false),
-		  __print_array(__entry->s.scaling_list_dc_coef_16x16,
-				ARRAY_SIZE(__entry->s.scaling_list_dc_coef_16x16),
-				sizeof(__entry->s.scaling_list_dc_coef_16x16[0])),
-		  __print_array(__entry->s.scaling_list_dc_coef_32x32,
-				ARRAY_SIZE(__entry->s.scaling_list_dc_coef_32x32),
-				sizeof(__entry->s.scaling_list_dc_coef_32x32[0]))
-	))
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
-	TP_ARGS(d),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
-	TP_fast_assign(__entry->d = *d),
-	TP_printk("\npic_order_cnt_val %d\n"
-		  "short_term_ref_pic_set_size %u\n"
-		  "long_term_ref_pic_set_size %u\n"
-		  "num_active_dpb_entries %u\n"
-		  "num_poc_st_curr_before %u\n"
-		  "num_poc_st_curr_after %u\n"
-		  "num_poc_lt_curr %u\n"
-		  "poc_st_curr_before %s\n"
-		  "poc_st_curr_after %s\n"
-		  "poc_lt_curr %s\n"
-		  "flags %s",
-		  __entry->d.pic_order_cnt_val,
-		  __entry->d.short_term_ref_pic_set_size,
-		  __entry->d.long_term_ref_pic_set_size,
-		  __entry->d.num_active_dpb_entries,
-		  __entry->d.num_poc_st_curr_before,
-		  __entry->d.num_poc_st_curr_after,
-		  __entry->d.num_poc_lt_curr,
-		  __print_array(__entry->d.poc_st_curr_before,
-				ARRAY_SIZE(__entry->d.poc_st_curr_before),
-				sizeof(__entry->d.poc_st_curr_before[0])),
-		  __print_array(__entry->d.poc_st_curr_after,
-				ARRAY_SIZE(__entry->d.poc_st_curr_after),
-				sizeof(__entry->d.poc_st_curr_after[0])),
-		  __print_array(__entry->d.poc_lt_curr,
-				ARRAY_SIZE(__entry->d.poc_lt_curr),
-				sizeof(__entry->d.poc_lt_curr[0])),
-		  __print_flags(__entry->d.flags, "|",
-		  {V4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PIC, "IRAP_PIC"},
-		  {V4L2_HEVC_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
-		  {V4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIOR, "NO_OUTPUT_OF_PRIOR"}
-	))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
-	TP_ARGS(lt),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
-	TP_fast_assign(__entry->lt = *lt),
-	TP_printk("\nflags %s\n"
-		  "lt_ref_pic_poc_lsb_sps %x\n",
-		  __print_flags(__entry->lt.flags, "|",
-		  {V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
-		  ),
-		  __entry->lt.lt_ref_pic_poc_lsb_sps
-	)
-)
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
-	TP_ARGS(st),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
-	TP_fast_assign(__entry->st = *st),
-	TP_printk("\nflags %s\n"
-		  "delta_idx_minus1: %u\n"
-		  "delta_rps_sign: %u\n"
-		  "abs_delta_rps_minus1: %u\n"
-		  "num_negative_pics: %u\n"
-		  "num_positive_pics: %u\n"
-		  "used_by_curr_pic: %08x\n"
-		  "use_delta_flag: %08x\n"
-		  "delta_poc_s0_minus1: %s\n"
-		  "delta_poc_s1_minus1: %s\n",
-		  __print_flags(__entry->st.flags, "|",
-		  {V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
-		  ),
-		  __entry->st.delta_idx_minus1,
-		  __entry->st.delta_rps_sign,
-		  __entry->st.abs_delta_rps_minus1,
-		  __entry->st.num_negative_pics,
-		  __entry->st.num_positive_pics,
-		  __entry->st.used_by_curr_pic,
-		  __entry->st.use_delta_flag,
-		  __print_array(__entry->st.delta_poc_s0_minus1,
-				ARRAY_SIZE(__entry->st.delta_poc_s0_minus1),
-				sizeof(__entry->st.delta_poc_s0_minus1[0])),
-		  __print_array(__entry->st.delta_poc_s1_minus1,
-				ARRAY_SIZE(__entry->st.delta_poc_s1_minus1),
-				sizeof(__entry->st.delta_poc_s1_minus1[0]))
-	)
-)
-
-
-DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
-	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
-	TP_ARGS(e),
-	TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
-	TP_fast_assign(__entry->e = *e),
-	TP_printk("\ntimestamp %llu\n"
-		  "flags %s\n"
-		  "field_pic %u\n"
-		  "pic_order_cnt_val %d\n",
-		__entry->e.timestamp,
-		__print_flags(__entry->e.flags, "|",
-		{V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
-		  ),
-		__entry->e.field_pic,
-		__entry->e.pic_order_cnt_val
-	))
-
-DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_pps_tmpl, v4l2_ctrl_hevc_pps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
-	TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_slice_params_tmpl, v4l2_ctrl_hevc_slice_params,
-	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_hevc_pred_weight_table_tmpl, v4l2_hevc_pred_weight_table,
-	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
-	TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_scaling_matrix_tmpl, v4l2_ctrl_hevc_scaling_matrix,
-	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_decode_params_tmpl, v4l2_ctrl_hevc_decode_params,
-	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
-	TP_ARGS(d)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl, v4l2_ctrl_hevc_ext_sps_lt_rps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
-	TP_ARGS(lt)
-);
-
-DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl, v4l2_ctrl_hevc_ext_sps_st_rps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
-	TP_ARGS(st)
-);
-
-DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
-	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
-	TP_ARGS(e)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-hevc
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-mpeg2.h b/drivers/media/test-drivers/visl/visl-trace-mpeg2.h
deleted file mode 100644
index ba6c65481194..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-mpeg2.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_MPEG2_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_MPEG2_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_mpeg2_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
-	TP_fast_assign(__entry->s = *s;),
-	TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
-		  "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
-		  __entry->s.horizontal_size,
-		  __entry->s.vertical_size,
-		  __entry->s.vbv_buffer_size,
-		  __entry->s.profile_and_level_indication,
-		  __entry->s.chroma_format,
-		  __print_flags(__entry->s.flags, "|",
-		  {V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE, "PROGRESSIVE"})
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
-	TP_fast_assign(__entry->p = *p;),
-	TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
-		  "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
-		  __entry->p.backward_ref_ts,
-		  __entry->p.forward_ref_ts,
-		  __print_flags(__entry->p.flags, "|",
-		  {V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST, "TOP_FIELD_FIRST"},
-		  {V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT, "FRAME_PRED_DCT"},
-		  {V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV, "CONCEALMENT_MV"},
-		  {V4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPE, "Q_SCALE_TYPE"},
-		  {V4L2_MPEG2_PIC_FLAG_INTRA_VLC, "INTA_VLC"},
-		  {V4L2_MPEG2_PIC_FLAG_ALT_SCAN, "ALT_SCAN"},
-		  {V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST, "REPEAT_FIRST"},
-		  {V4L2_MPEG2_PIC_FLAG_PROGRESSIVE, "PROGRESSIVE"}),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.f_code,
-				   sizeof(__entry->p.f_code),
-				   false),
-		  __entry->p.picture_coding_type,
-		  __entry->p.picture_structure,
-		  __entry->p.intra_dc_precision
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
-	TP_ARGS(q),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
-	TP_fast_assign(__entry->q = *q;),
-	TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
-		  "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
-		  __print_array(__entry->q.intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
-				sizeof(__entry->q.intra_quantiser_matrix[0])),
-		  __print_array(__entry->q.non_intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.non_intra_quantiser_matrix),
-				sizeof(__entry->q.non_intra_quantiser_matrix[0])),
-		  __print_array(__entry->q.chroma_intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.chroma_intra_quantiser_matrix),
-				sizeof(__entry->q.chroma_intra_quantiser_matrix[0])),
-		  __print_array(__entry->q.chroma_non_intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.chroma_non_intra_quantiser_matrix),
-				sizeof(__entry->q.chroma_non_intra_quantiser_matrix[0]))
-		  )
-)
-
-DEFINE_EVENT(v4l2_ctrl_mpeg2_seq_tmpl, v4l2_ctrl_mpeg2_sequence,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
-	TP_ARGS(s)
-);
-
-DEFINE_EVENT(v4l2_ctrl_mpeg2_pic_tmpl, v4l2_ctrl_mpeg2_picture,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
-	TP_ARGS(p)
-);
-
-DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
-	TP_ARGS(q)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-mpeg2
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-points.c b/drivers/media/test-drivers/visl/visl-trace-points.c
deleted file mode 100644
index 321ff732c682..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-points.c
+++ /dev/null
@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-#include "visl.h"
-
-#define CREATE_TRACE_POINTS
-#include "visl-trace-fwht.h"
-#include "visl-trace-mpeg2.h"
-#include "visl-trace-vp8.h"
-#include "visl-trace-vp9.h"
-#include "visl-trace-h264.h"
-#include "visl-trace-hevc.h"
-#include "visl-trace-av1.h"
diff --git a/drivers/media/test-drivers/visl/visl-trace-vp8.h b/drivers/media/test-drivers/visl/visl-trace-vp8.h
deleted file mode 100644
index dabe17d69ddc..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-vp8.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_VP8_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_VP8_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_vp8_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
-	TP_printk("\nentropy.coeff_probs {%s}\n"
-		  "entropy.y_mode_probs %s\n"
-		  "entropy.uv_mode_probs %s\n"
-		  "entropy.mv_probs {%s}",
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->f.entropy.coeff_probs,
-				   sizeof(__entry->f.entropy.coeff_probs),
-				   false),
-		  __print_array(__entry->f.entropy.y_mode_probs,
-				ARRAY_SIZE(__entry->f.entropy.y_mode_probs),
-				sizeof(__entry->f.entropy.y_mode_probs[0])),
-		  __print_array(__entry->f.entropy.uv_mode_probs,
-				ARRAY_SIZE(__entry->f.entropy.uv_mode_probs),
-				sizeof(__entry->f.entropy.uv_mode_probs[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->f.entropy.mv_probs,
-				   sizeof(__entry->f.entropy.mv_probs),
-				   false)
-		  )
-)
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
-	TP_printk("\nsegment.quant_update %s\n"
-		  "segment.lf_update %s\n"
-		  "segment.segment_probs %s\n"
-		  "segment.flags %s\n"
-		  "lf.ref_frm_delta %s\n"
-		  "lf.mb_mode_delta %s\n"
-		  "lf.sharpness_level %u\n"
-		  "lf.level %u\n"
-		  "lf.flags %s\n"
-		  "quant.y_ac_qi %u\n"
-		  "quant.y_dc_delta %d\n"
-		  "quant.y2_dc_delta %d\n"
-		  "quant.y2_ac_delta %d\n"
-		  "quant.uv_dc_delta %d\n"
-		  "quant.uv_ac_delta %d\n"
-		  "coder_state.range %u\n"
-		  "coder_state.value %u\n"
-		  "coder_state.bit_count %u\n"
-		  "width %u\n"
-		  "height %u\n"
-		  "horizontal_scale %u\n"
-		  "vertical_scale %u\n"
-		  "version %u\n"
-		  "prob_skip_false %u\n"
-		  "prob_intra %u\n"
-		  "prob_last %u\n"
-		  "prob_gf %u\n"
-		  "num_dct_parts %u\n"
-		  "first_part_size %u\n"
-		  "first_part_header_bits %u\n"
-		  "dct_part_sizes %s\n"
-		  "last_frame_ts %llu\n"
-		  "golden_frame_ts %llu\n"
-		  "alt_frame_ts %llu\n"
-		  "flags %s",
-		  __print_array(__entry->f.segment.quant_update,
-				ARRAY_SIZE(__entry->f.segment.quant_update),
-				sizeof(__entry->f.segment.quant_update[0])),
-		  __print_array(__entry->f.segment.lf_update,
-				ARRAY_SIZE(__entry->f.segment.lf_update),
-				sizeof(__entry->f.segment.lf_update[0])),
-		  __print_array(__entry->f.segment.segment_probs,
-				ARRAY_SIZE(__entry->f.segment.segment_probs),
-				sizeof(__entry->f.segment.segment_probs[0])),
-		  __print_flags(__entry->f.segment.flags, "|",
-		  {V4L2_VP8_SEGMENT_FLAG_ENABLED, "SEGMENT_ENABLED"},
-		  {V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP, "SEGMENT_UPDATE_MAP"},
-		  {V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA, "SEGMENT_UPDATE_FEATURE_DATA"},
-		  {V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE, "SEGMENT_DELTA_VALUE_MODE"}),
-		  __print_array(__entry->f.lf.ref_frm_delta,
-				ARRAY_SIZE(__entry->f.lf.ref_frm_delta),
-				sizeof(__entry->f.lf.ref_frm_delta[0])),
-		  __print_array(__entry->f.lf.mb_mode_delta,
-				ARRAY_SIZE(__entry->f.lf.mb_mode_delta),
-				sizeof(__entry->f.lf.mb_mode_delta[0])),
-		  __entry->f.lf.sharpness_level,
-		  __entry->f.lf.level,
-		  __print_flags(__entry->f.lf.flags, "|",
-		  {V4L2_VP8_LF_ADJ_ENABLE, "LF_ADJ_ENABLED"},
-		  {V4L2_VP8_LF_DELTA_UPDATE, "LF_DELTA_UPDATE"},
-		  {V4L2_VP8_LF_FILTER_TYPE_SIMPLE, "LF_FILTER_TYPE_SIMPLE"}),
-		  __entry->f.quant.y_ac_qi,
-		  __entry->f.quant.y_dc_delta,
-		  __entry->f.quant.y2_dc_delta,
-		  __entry->f.quant.y2_ac_delta,
-		  __entry->f.quant.uv_dc_delta,
-		  __entry->f.quant.uv_ac_delta,
-		  __entry->f.coder_state.range,
-		  __entry->f.coder_state.value,
-		  __entry->f.coder_state.bit_count,
-		  __entry->f.width,
-		  __entry->f.height,
-		  __entry->f.horizontal_scale,
-		  __entry->f.vertical_scale,
-		  __entry->f.version,
-		  __entry->f.prob_skip_false,
-		  __entry->f.prob_intra,
-		  __entry->f.prob_last,
-		  __entry->f.prob_gf,
-		  __entry->f.num_dct_parts,
-		  __entry->f.first_part_size,
-		  __entry->f.first_part_header_bits,
-		  __print_array(__entry->f.dct_part_sizes,
-				ARRAY_SIZE(__entry->f.dct_part_sizes),
-				sizeof(__entry->f.dct_part_sizes[0])),
-		  __entry->f.last_frame_ts,
-		  __entry->f.golden_frame_ts,
-		  __entry->f.alt_frame_ts,
-		  __print_flags(__entry->f.flags, "|",
-		  {V4L2_VP8_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
-		  {V4L2_VP8_FRAME_FLAG_EXPERIMENTAL, "EXPERIMENTAL"},
-		  {V4L2_VP8_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
-		  {V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF, "MB_NO_SKIP_COEFF"},
-		  {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
-		  {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"})
-		  )
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp8_frame_tmpl, v4l2_ctrl_vp8_frame,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-vp8
-#include <trace/define_trace.h>
diff --git a/drivers/media/test-drivers/visl/visl-trace-vp9.h b/drivers/media/test-drivers/visl/visl-trace-vp9.h
deleted file mode 100644
index 362b92b07f93..000000000000
--- a/drivers/media/test-drivers/visl/visl-trace-vp9.h
+++ /dev/null
@@ -1,292 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#if !defined(_VISL_TRACE_VP9_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _VISL_TRACE_VP9_H_
-
-#include <linux/tracepoint.h>
-#include "visl.h"
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM visl_vp9_controls
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
-	TP_printk("\nlf.ref_deltas %s\n"
-		  "lf.mode_deltas %s\n"
-		  "lf.level %u\n"
-		  "lf.sharpness %u\n"
-		  "lf.flags %s\n"
-		  "quant.base_q_idx %u\n"
-		  "quant.delta_q_y_dc %d\n"
-		  "quant.delta_q_uv_dc %d\n"
-		  "quant.delta_q_uv_ac %d\n"
-		  "seg.feature_data {%s}\n"
-		  "seg.feature_enabled %s\n"
-		  "seg.tree_probs %s\n"
-		  "seg.pred_probs %s\n"
-		  "seg.flags %s\n"
-		  "flags %s\n"
-		  "compressed_header_size %u\n"
-		  "uncompressed_header_size %u\n"
-		  "frame_width_minus_1 %u\n"
-		  "frame_height_minus_1 %u\n"
-		  "render_width_minus_1 %u\n"
-		  "render_height_minus_1 %u\n"
-		  "last_frame_ts %llu\n"
-		  "golden_frame_ts %llu\n"
-		  "alt_frame_ts %llu\n"
-		  "ref_frame_sign_bias %s\n"
-		  "reset_frame_context %s\n"
-		  "frame_context_idx %u\n"
-		  "profile %u\n"
-		  "bit_depth %u\n"
-		  "interpolation_filter %s\n"
-		  "tile_cols_log2 %u\n"
-		  "tile_rows_log_2 %u\n"
-		  "reference_mode %s\n",
-		  __print_array(__entry->f.lf.ref_deltas,
-				ARRAY_SIZE(__entry->f.lf.ref_deltas),
-				sizeof(__entry->f.lf.ref_deltas[0])),
-		  __print_array(__entry->f.lf.mode_deltas,
-				ARRAY_SIZE(__entry->f.lf.mode_deltas),
-				sizeof(__entry->f.lf.mode_deltas[0])),
-		  __entry->f.lf.level,
-		  __entry->f.lf.sharpness,
-		  __print_flags(__entry->f.lf.flags, "|",
-		  {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
-		  {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"}),
-		  __entry->f.quant.base_q_idx,
-		  __entry->f.quant.delta_q_y_dc,
-		  __entry->f.quant.delta_q_uv_dc,
-		  __entry->f.quant.delta_q_uv_ac,
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->f.seg.feature_data,
-				   sizeof(__entry->f.seg.feature_data),
-				   false),
-		  __print_array(__entry->f.seg.feature_enabled,
-				ARRAY_SIZE(__entry->f.seg.feature_enabled),
-				sizeof(__entry->f.seg.feature_enabled[0])),
-		  __print_array(__entry->f.seg.tree_probs,
-				ARRAY_SIZE(__entry->f.seg.tree_probs),
-				sizeof(__entry->f.seg.tree_probs[0])),
-		  __print_array(__entry->f.seg.pred_probs,
-				ARRAY_SIZE(__entry->f.seg.pred_probs),
-				sizeof(__entry->f.seg.pred_probs[0])),
-		  __print_flags(__entry->f.seg.flags, "|",
-		  {V4L2_VP9_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
-		  {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
-		  {V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
-		  {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
-		  {V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE, "ABS_OR_DELTA_UPDATE"}),
-		  __print_flags(__entry->f.flags, "|",
-		  {V4L2_VP9_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
-		  {V4L2_VP9_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
-		  {V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT, "ERROR_RESILIENT"},
-		  {V4L2_VP9_FRAME_FLAG_INTRA_ONLY, "INTRA_ONLY"},
-		  {V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV, "ALLOW_HIGH_PREC_MV"},
-		  {V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX, "REFRESH_FRAME_CTX"},
-		  {V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE, "PARALLEL_DEC_MODE"},
-		  {V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING, "X_SUBSAMPLING"},
-		  {V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING, "Y_SUBSAMPLING"},
-		  {V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING, "COLOR_RANGE_FULL_SWING"}),
-		  __entry->f.compressed_header_size,
-		  __entry->f.uncompressed_header_size,
-		  __entry->f.frame_width_minus_1,
-		  __entry->f.frame_height_minus_1,
-		  __entry->f.render_width_minus_1,
-		  __entry->f.render_height_minus_1,
-		  __entry->f.last_frame_ts,
-		  __entry->f.golden_frame_ts,
-		  __entry->f.alt_frame_ts,
-		  __print_symbolic(__entry->f.ref_frame_sign_bias,
-		  {V4L2_VP9_SIGN_BIAS_LAST, "SIGN_BIAS_LAST"},
-		  {V4L2_VP9_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
-		  {V4L2_VP9_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"}),
-		  __print_symbolic(__entry->f.reset_frame_context,
-		  {V4L2_VP9_RESET_FRAME_CTX_NONE, "RESET_FRAME_CTX_NONE"},
-		  {V4L2_VP9_RESET_FRAME_CTX_SPEC, "RESET_FRAME_CTX_SPEC"},
-		  {V4L2_VP9_RESET_FRAME_CTX_ALL, "RESET_FRAME_CTX_ALL"}),
-		  __entry->f.frame_context_idx,
-		  __entry->f.profile,
-		  __entry->f.bit_depth,
-		  __print_symbolic(__entry->f.interpolation_filter,
-		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP, "INTERP_FILTER_EIGHTTAP"},
-		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTH, "INTERP_FILTER_EIGHTTAP_SMOOTH"},
-		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARP, "INTERP_FILTER_EIGHTTAP_SHARP"},
-		  {V4L2_VP9_INTERP_FILTER_BILINEAR, "INTERP_FILTER_BILINEAR"},
-		  {V4L2_VP9_INTERP_FILTER_SWITCHABLE, "INTERP_FILTER_SWITCHABLE"}),
-		  __entry->f.tile_cols_log2,
-		  __entry->f.tile_rows_log2,
-		  __print_symbolic(__entry->f.reference_mode,
-		  {V4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCE, "REFERENCE_MODE_SINGLE_REFERENCE"},
-		  {V4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCE, "REFERENCE_MODE_COMPOUND_REFERENCE"},
-		  {V4L2_VP9_REFERENCE_MODE_SELECT, "REFERENCE_MODE_SELECT"}))
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
-	TP_fast_assign(__entry->h = *h;),
-	TP_printk("\ntx_mode %s\n"
-		  "tx8 {%s}\n"
-		  "tx16 {%s}\n"
-		  "tx32 {%s}\n"
-		  "skip %s\n"
-		  "inter_mode {%s}\n"
-		  "interp_filter {%s}\n"
-		  "is_inter %s\n"
-		  "comp_mode %s\n"
-		  "single_ref {%s}\n"
-		  "comp_ref %s\n"
-		  "y_mode {%s}\n"
-		  "uv_mode {%s}\n"
-		  "partition {%s}\n",
-		  __print_symbolic(__entry->h.tx_mode,
-		  {V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
-		  {V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
-		  {V4L2_VP9_TX_MODE_ALLOW_16X16, "TX_MODE_ALLOW_16X16"},
-		  {V4L2_VP9_TX_MODE_ALLOW_32X32, "TX_MODE_ALLOW_32X32"},
-		  {V4L2_VP9_TX_MODE_SELECT, "TX_MODE_SELECT"}),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.tx8,
-				   sizeof(__entry->h.tx8),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.tx16,
-				   sizeof(__entry->h.tx16),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.tx32,
-				   sizeof(__entry->h.tx32),
-				   false),
-		  __print_array(__entry->h.skip,
-				ARRAY_SIZE(__entry->h.skip),
-				sizeof(__entry->h.skip[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.inter_mode,
-				   sizeof(__entry->h.inter_mode),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.interp_filter,
-				   sizeof(__entry->h.interp_filter),
-				   false),
-		  __print_array(__entry->h.is_inter,
-				ARRAY_SIZE(__entry->h.is_inter),
-				sizeof(__entry->h.is_inter[0])),
-		  __print_array(__entry->h.comp_mode,
-				ARRAY_SIZE(__entry->h.comp_mode),
-				sizeof(__entry->h.comp_mode[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.single_ref,
-				   sizeof(__entry->h.single_ref),
-				   false),
-		  __print_array(__entry->h.comp_ref,
-				ARRAY_SIZE(__entry->h.comp_ref),
-				sizeof(__entry->h.comp_ref[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.y_mode,
-				   sizeof(__entry->h.y_mode),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.uv_mode,
-				   sizeof(__entry->h.uv_mode),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.partition,
-				   sizeof(__entry->h.partition),
-				   false)
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
-	TP_fast_assign(__entry->h = *h;),
-	TP_printk("\n coef {%s}",
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.coef,
-				   sizeof(__entry->h.coef),
-				   false)
-	)
-);
-
-DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
-	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
-	TP_fast_assign(__entry->p = *p;),
-	TP_printk("\n joint %s\n"
-		  "sign %s\n"
-		  "classes {%s}\n"
-		  "class0_bit %s\n"
-		  "bits {%s}\n"
-		  "class0_fr {%s}\n"
-		  "fr {%s}\n"
-		  "class0_hp %s\n"
-		  "hp %s\n",
-		  __print_array(__entry->p.joint,
-				ARRAY_SIZE(__entry->p.joint),
-				sizeof(__entry->p.joint[0])),
-		  __print_array(__entry->p.sign,
-				ARRAY_SIZE(__entry->p.sign),
-				sizeof(__entry->p.sign[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.classes,
-				   sizeof(__entry->p.classes),
-				   false),
-		  __print_array(__entry->p.class0_bit,
-				ARRAY_SIZE(__entry->p.class0_bit),
-				sizeof(__entry->p.class0_bit[0])),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.bits,
-				   sizeof(__entry->p.bits),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.class0_fr,
-				   sizeof(__entry->p.class0_fr),
-				   false),
-		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.fr,
-				   sizeof(__entry->p.fr),
-				   false),
-		  __print_array(__entry->p.class0_hp,
-				ARRAY_SIZE(__entry->p.class0_hp),
-				sizeof(__entry->p.class0_hp[0])),
-		  __print_array(__entry->p.hp,
-				ARRAY_SIZE(__entry->p.hp),
-				sizeof(__entry->p.hp[0]))
-	)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp9_frame_tmpl, v4l2_ctrl_vp9_frame,
-	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
-	TP_ARGS(f)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp9_compressed_hdr_tmpl, v4l2_ctrl_vp9_compressed_hdr,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h)
-);
-
-DEFINE_EVENT(v4l2_ctrl_vp9_compressed_coef_tmpl, v4l2_ctrl_vp9_compressed_coeff,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h)
-);
-
-
-DEFINE_EVENT(v4l2_vp9_mv_probs_tmpl, v4l2_vp9_mv_probs,
-	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
-	TP_ARGS(p)
-);
-
-#endif
-
-#undef TRACE_INCLUDE_PATH
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_PATH ../../drivers/media/test-drivers/visl
-#define TRACE_INCLUDE_FILE visl-trace-vp9
-#include <trace/define_trace.h>
diff --git a/drivers/media/v4l2-core/v4l2-trace.c b/drivers/media/v4l2-core/v4l2-trace.c
index 95f3b02e1f84..183d5ecb49c5 100644
--- a/drivers/media/v4l2-core/v4l2-trace.c
+++ b/drivers/media/v4l2-core/v4l2-trace.c
@@ -5,8 +5,53 @@
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/v4l2.h>
+#include <trace/events/v4l2_controls.h>
 
 EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_buf_done);
 EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_buf_queue);
 EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_dqbuf);
 EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_qbuf);
+
+/* Export AV1 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_sequence);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_frame);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_tile_group_entry);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_film_grain);
+
+/* Export FWHT controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_fwht_params);
+
+/* Export H264 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_sps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_pps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_scaling_matrix);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_pred_weights);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_slice_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_h264_ref_pic_list0);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_h264_ref_pic_list1);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_h264_decode_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_h264_dpb_entry);
+
+/* Export HEVC controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_sps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_pps);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_slice_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hevc_pred_weight_table);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_scaling_matrix);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_hevc_decode_params);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hevc_dpb_entry);
+
+/* Export MPEG2 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_mpeg2_sequence);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_mpeg2_picture);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_mpeg2_quantisation);
+
+/* Export VP8 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp8_frame);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp8_entropy);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp9_frame);
+
+/* Export VP9 controls */
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp9_compressed_hdr);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_vp9_compressed_coeff);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_vp9_mv_probs);
diff --git a/include/trace/events/v4l2_controls.h b/include/trace/events/v4l2_controls.h
new file mode 100644
index 000000000000..9c74309b31ef
--- /dev/null
+++ b/include/trace/events/v4l2_controls.h
@@ -0,0 +1,1645 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#if !defined(_TRACE_V4L2_CONTROLS_H_) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_V4L2_CONTROLS_H_
+
+#include <linux/tracepoint.h>
+#include <linux/v4l2-controls.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM v4l2_controls
+
+/* AV1 controls */
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
+	TP_fast_assign(__entry->s = *s;),
+	TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
+		  "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
+		  __print_flags(__entry->s.flags, "|",
+		  {V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
+		  {V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA, "ENABLE_FILTER_INTRA"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER, "ENABLE_INTRA_EDGE_FILTER"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND, "ENABLE_INTERINTRA_COMPOUND"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND, "ENABLE_MASKED_COMPOUND"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION, "ENABLE_WARPED_MOTION"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER, "ENABLE_DUAL_FILTER"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT, "ENABLE_ORDER_HINT"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP, "ENABLE_JNT_COMP"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS, "ENABLE_REF_FRAME_MVS"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES, "ENABLE_SUPERRES"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF, "ENABLE_CDEF"},
+		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION, "ENABLE_RESTORATION"},
+		  {V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME, "MONO_CHROME"},
+		  {V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE, "COLOR_RANGE"},
+		  {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X, "SUBSAMPLING_X"},
+		  {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y, "SUBSAMPLING_Y"},
+		  {V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT, "FILM_GRAIN_PARAMS_PRESENT"},
+		  {V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q, "SEPARATE_UV_DELTA_Q"}),
+		  __entry->s.seq_profile,
+		  __entry->s.order_hint_bits,
+		  __entry->s.bit_depth,
+		  __entry->s.max_frame_width_minus_1,
+		  __entry->s.max_frame_height_minus_1
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
+	TP_ARGS(t),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
+	TP_fast_assign(__entry->t = *t;),
+	TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
+		  __entry->t.tile_offset,
+		  __entry->t.tile_size,
+		  __entry->t.tile_row,
+		  __entry->t.tile_col
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
+	TP_ARGS(f),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
+	TP_fast_assign(__entry->f = *f;),
+	TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
+		  "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
+		  "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
+		  "tile_info.width_in_sbs_minus_1: %s\ntile_info.height_in_sbs_minus_1: %s\n"
+		  "tile_info.tile_size_bytes: %u\nquantization.flags: %s\n"
+		  "quantization.base_q_idx: %u\nquantization.delta_q_y_dc: %d\n"
+		  "quantization.delta_q_u_dc: %d\nquantization.delta_q_u_ac: %d\n"
+		  "quantization.delta_q_v_dc: %d\nquantization.delta_q_v_ac: %d\n"
+		  "quantization.qm_y: %u\nquantization.qm_u: %u\nquantization.qm_v: %u\n"
+		  "quantization.delta_q_res: %u\nsuperres_denom: %u\nsegmentation.flags: %s\n"
+		  "segmentation.last_active_seg_id: %u\nsegmentation.feature_enabled:%s\n"
+		  "loop_filter.flags: %s\nloop_filter.level: %s\nloop_filter.sharpness: %u\n"
+		  "loop_filter.ref_deltas: %s\nloop_filter.mode_deltas: %s\n"
+		  "loop_filter.delta_lf_res: %u\ncdef.damping_minus_3: %u\ncdef.bits: %u\n"
+		  "cdef.y_pri_strength: %s\ncdef.y_sec_strength: %s\n"
+		  "cdef.uv_pri_strength: %s\ncdef.uv_sec_strength:%s\nskip_mode_frame: %s\n"
+		  "primary_ref_frame: %u\nloop_restoration.flags: %s\n"
+		  "loop_restoration.lr_unit_shift: %u\nloop_restoration.lr_uv_shift: %u\n"
+		  "loop_restoration.frame_restoration_type: %s\n"
+		  "loop_restoration.loop_restoration_size: %s\nflags: %s\norder_hint: %u\n"
+		  "upscaled_width: %u\nframe_width_minus_1: %u\nframe_height_minus_1: %u\n"
+		  "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
+		  "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
+		  "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
+		  __print_flags(__entry->f.tile_info.flags, "|",
+		  {V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
+		  __entry->f.tile_info.context_update_tile_id,
+		  __entry->f.tile_info.tile_cols,
+		  __entry->f.tile_info.tile_rows,
+		  __print_array(__entry->f.tile_info.mi_col_starts,
+				ARRAY_SIZE(__entry->f.tile_info.mi_col_starts),
+				sizeof(__entry->f.tile_info.mi_col_starts[0])),
+		  __print_array(__entry->f.tile_info.mi_row_starts,
+				ARRAY_SIZE(__entry->f.tile_info.mi_row_starts),
+				sizeof(__entry->f.tile_info.mi_row_starts[0])),
+		  __print_array(__entry->f.tile_info.width_in_sbs_minus_1,
+				ARRAY_SIZE(__entry->f.tile_info.width_in_sbs_minus_1),
+				sizeof(__entry->f.tile_info.width_in_sbs_minus_1[0])),
+		  __print_array(__entry->f.tile_info.height_in_sbs_minus_1,
+				ARRAY_SIZE(__entry->f.tile_info.height_in_sbs_minus_1),
+				sizeof(__entry->f.tile_info.height_in_sbs_minus_1[0])),
+		  __entry->f.tile_info.tile_size_bytes,
+		  __print_flags(__entry->f.quantization.flags, "|",
+		  {V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA, "DIFF_UV_DELTA"},
+		  {V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX, "USING_QMATRIX"},
+		  {V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT, "DELTA_Q_PRESENT"}),
+		  __entry->f.quantization.base_q_idx,
+		  __entry->f.quantization.delta_q_y_dc,
+		  __entry->f.quantization.delta_q_u_dc,
+		  __entry->f.quantization.delta_q_u_ac,
+		  __entry->f.quantization.delta_q_v_dc,
+		  __entry->f.quantization.delta_q_v_ac,
+		  __entry->f.quantization.qm_y,
+		  __entry->f.quantization.qm_u,
+		  __entry->f.quantization.qm_v,
+		  __entry->f.quantization.delta_q_res,
+		  __entry->f.superres_denom,
+		  __print_flags(__entry->f.segmentation.flags, "|",
+		  {V4L2_AV1_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
+		  {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
+		  {V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
+		  {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
+		  {V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP, "SEG_ID_PRE_SKIP"}),
+		  __entry->f.segmentation.last_active_seg_id,
+		  __print_array(__entry->f.segmentation.feature_enabled,
+				ARRAY_SIZE(__entry->f.segmentation.feature_enabled),
+				sizeof(__entry->f.segmentation.feature_enabled[0])),
+		  __print_flags(__entry->f.loop_filter.flags, "|",
+		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
+		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"},
+		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT, "DELTA_LF_PRESENT"},
+		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI, "DELTA_LF_MULTI"}),
+		  __print_array(__entry->f.loop_filter.level,
+				ARRAY_SIZE(__entry->f.loop_filter.level),
+				sizeof(__entry->f.loop_filter.level[0])),
+		  __entry->f.loop_filter.sharpness,
+		  __print_array(__entry->f.loop_filter.ref_deltas,
+				ARRAY_SIZE(__entry->f.loop_filter.ref_deltas),
+				sizeof(__entry->f.loop_filter.ref_deltas[0])),
+		  __print_array(__entry->f.loop_filter.mode_deltas,
+				ARRAY_SIZE(__entry->f.loop_filter.mode_deltas),
+				sizeof(__entry->f.loop_filter.mode_deltas[0])),
+		  __entry->f.loop_filter.delta_lf_res,
+		  __entry->f.cdef.damping_minus_3,
+		  __entry->f.cdef.bits,
+		  __print_array(__entry->f.cdef.y_pri_strength,
+				ARRAY_SIZE(__entry->f.cdef.y_pri_strength),
+				sizeof(__entry->f.cdef.y_pri_strength[0])),
+		  __print_array(__entry->f.cdef.y_sec_strength,
+				ARRAY_SIZE(__entry->f.cdef.y_sec_strength),
+				sizeof(__entry->f.cdef.y_sec_strength[0])),
+		  __print_array(__entry->f.cdef.uv_pri_strength,
+				ARRAY_SIZE(__entry->f.cdef.uv_pri_strength),
+				sizeof(__entry->f.cdef.uv_pri_strength[0])),
+		  __print_array(__entry->f.cdef.uv_sec_strength,
+				ARRAY_SIZE(__entry->f.cdef.uv_sec_strength),
+				sizeof(__entry->f.cdef.uv_sec_strength[0])),
+		  __print_array(__entry->f.skip_mode_frame,
+				ARRAY_SIZE(__entry->f.skip_mode_frame),
+				sizeof(__entry->f.skip_mode_frame[0])),
+		  __entry->f.primary_ref_frame,
+		  __print_flags(__entry->f.loop_restoration.flags, "|",
+		  {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR, "USES_LR"},
+		  {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR, "USES_CHROMA_LR"}),
+		  __entry->f.loop_restoration.lr_unit_shift,
+		  __entry->f.loop_restoration.lr_uv_shift,
+		  __print_array(__entry->f.loop_restoration.frame_restoration_type,
+				ARRAY_SIZE(__entry->f.loop_restoration.frame_restoration_type),
+				sizeof(__entry->f.loop_restoration.frame_restoration_type[0])),
+		  __print_array(__entry->f.loop_restoration.loop_restoration_size,
+				ARRAY_SIZE(__entry->f.loop_restoration.loop_restoration_size),
+				sizeof(__entry->f.loop_restoration.loop_restoration_size[0])),
+		  __print_flags(__entry->f.flags, "|",
+		  {V4L2_AV1_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
+		  {V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME, "SHOWABLE_FRAME"},
+		  {V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE, "ERROR_RESILIENT_MODE"},
+		  {V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE, "DISABLE_CDF_UPDATE"},
+		  {V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS, "ALLOW_SCREEN_CONTENT_TOOLS"},
+		  {V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV, "FORCE_INTEGER_MV"},
+		  {V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC, "ALLOW_INTRABC"},
+		  {V4L2_AV1_FRAME_FLAG_USE_SUPERRES, "USE_SUPERRES"},
+		  {V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV, "ALLOW_HIGH_PRECISION_MV"},
+		  {V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE, "IS_MOTION_MODE_SWITCHABLE"},
+		  {V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS, "USE_REF_FRAME_MVS"},
+		  {V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF,
+		   "DISABLE_FRAME_END_UPDATE_CDF"},
+		  {V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION, "ALLOW_WARPED_MOTION"},
+		  {V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT, "REFERENCE_SELECT"},
+		  {V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET, "REDUCED_TX_SET"},
+		  {V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED, "SKIP_MODE_ALLOWED"},
+		  {V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT, "SKIP_MODE_PRESENT"},
+		  {V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE, "FRAME_SIZE_OVERRIDE"},
+		  {V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT, "BUFFER_REMOVAL_TIME_PRESENT"},
+		  {V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING, "FRAME_REFS_SHORT_SIGNALING"}),
+		  __entry->f.order_hint,
+		  __entry->f.upscaled_width,
+		  __entry->f.frame_width_minus_1,
+		  __entry->f.frame_height_minus_1,
+		  __entry->f.render_width_minus_1,
+		  __entry->f.render_height_minus_1,
+		  __entry->f.current_frame_id,
+		  __print_array(__entry->f.buffer_removal_time,
+				ARRAY_SIZE(__entry->f.buffer_removal_time),
+				sizeof(__entry->f.buffer_removal_time[0])),
+		  __print_array(__entry->f.order_hints,
+				ARRAY_SIZE(__entry->f.order_hints),
+				sizeof(__entry->f.order_hints[0])),
+		  __print_array(__entry->f.reference_frame_ts,
+				ARRAY_SIZE(__entry->f.reference_frame_ts),
+				sizeof(__entry->f.reference_frame_ts[0])),
+		  __print_array(__entry->f.ref_frame_idx,
+				ARRAY_SIZE(__entry->f.ref_frame_idx),
+				sizeof(__entry->f.ref_frame_idx[0])),
+		  __entry->f.refresh_frame_flags
+	)
+);
+
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
+	TP_ARGS(f),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
+	TP_fast_assign(__entry->f = *f;),
+	TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
+		  "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
+		  "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
+		  "point_cb_scaling: %s\nnum_cr_points: %u\npoint_cr_value: %s\n"
+		  "point_cr_scaling: %s\ngrain_scaling_minus_8: %u\nar_coeff_lag: %u\n"
+		  "ar_coeffs_y_plus_128: %s\nar_coeffs_cb_plus_128: %s\n"
+		  "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
+		  "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
+		  "cb_offset: %u\ncr_offset: %u\n",
+		  __print_flags(__entry->f.flags, "|",
+		  {V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
+		  {V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
+		  {V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA, "CHROMA_SCALING_FROM_LUMA"},
+		  {V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP, "OVERLAP"},
+		  {V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE, "CLIP_TO_RESTRICTED_RANGE"}),
+		  __entry->f.cr_mult,
+		  __entry->f.grain_seed,
+		  __entry->f.film_grain_params_ref_idx,
+		  __entry->f.num_y_points,
+		  __print_array(__entry->f.point_y_value,
+				ARRAY_SIZE(__entry->f.point_y_value),
+				sizeof(__entry->f.point_y_value[0])),
+		  __print_array(__entry->f.point_y_scaling,
+				ARRAY_SIZE(__entry->f.point_y_scaling),
+				sizeof(__entry->f.point_y_scaling[0])),
+		  __entry->f.num_cb_points,
+		  __print_array(__entry->f.point_cb_value,
+				ARRAY_SIZE(__entry->f.point_cb_value),
+				sizeof(__entry->f.point_cb_value[0])),
+		  __print_array(__entry->f.point_cb_scaling,
+				ARRAY_SIZE(__entry->f.point_cb_scaling),
+				sizeof(__entry->f.point_cb_scaling[0])),
+		  __entry->f.num_cr_points,
+		  __print_array(__entry->f.point_cr_value,
+				ARRAY_SIZE(__entry->f.point_cr_value),
+				sizeof(__entry->f.point_cr_value[0])),
+		  __print_array(__entry->f.point_cr_scaling,
+				ARRAY_SIZE(__entry->f.point_cr_scaling),
+				sizeof(__entry->f.point_cr_scaling[0])),
+		  __entry->f.grain_scaling_minus_8,
+		  __entry->f.ar_coeff_lag,
+		  __print_array(__entry->f.ar_coeffs_y_plus_128,
+				ARRAY_SIZE(__entry->f.ar_coeffs_y_plus_128),
+				sizeof(__entry->f.ar_coeffs_y_plus_128[0])),
+		  __print_array(__entry->f.ar_coeffs_cb_plus_128,
+				ARRAY_SIZE(__entry->f.ar_coeffs_cb_plus_128),
+				sizeof(__entry->f.ar_coeffs_cb_plus_128[0])),
+		  __print_array(__entry->f.ar_coeffs_cr_plus_128,
+				ARRAY_SIZE(__entry->f.ar_coeffs_cr_plus_128),
+				sizeof(__entry->f.ar_coeffs_cr_plus_128[0])),
+		  __entry->f.ar_coeff_shift_minus_6,
+		  __entry->f.grain_scale_shift,
+		  __entry->f.cb_mult,
+		  __entry->f.cb_luma_mult,
+		  __entry->f.cr_luma_mult,
+		  __entry->f.cb_offset,
+		  __entry->f.cr_offset
+	)
+)
+
+DEFINE_EVENT(v4l2_ctrl_av1_seq_tmpl, v4l2_ctrl_av1_sequence,
+	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_av1_frame_tmpl, v4l2_ctrl_av1_frame,
+	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
+	TP_ARGS(f)
+);
+
+DEFINE_EVENT(v4l2_ctrl_av1_tge_tmpl, v4l2_ctrl_av1_tile_group_entry,
+	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
+	TP_ARGS(t)
+);
+
+DEFINE_EVENT(v4l2_ctrl_av1_film_grain_tmpl, v4l2_ctrl_av1_film_grain,
+	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
+	TP_ARGS(f)
+);
+
+/* FWHT controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(
+			 __field(u64, backward_ref_ts)
+			 __field(u32, version)
+			 __field(u32, width)
+			 __field(u32, height)
+			 __field(u32, flags)
+			 __field(u32, colorspace)
+			 __field(u32, xfer_func)
+			 __field(u32, ycbcr_enc)
+			 __field(u32, quantization)
+			 ),
+	TP_fast_assign(
+		       __entry->backward_ref_ts = p->backward_ref_ts;
+		       __entry->version = p->version;
+		       __entry->width = p->width;
+		       __entry->height = p->height;
+		       __entry->flags = p->flags;
+		       __entry->colorspace = p->colorspace;
+		       __entry->xfer_func = p->xfer_func;
+		       __entry->ycbcr_enc = p->ycbcr_enc;
+		       __entry->quantization = p->quantization;
+		       ),
+	TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u xfer_func %u ycbcr_enc %u quantization %u",
+		  __entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
+		  __print_flags(__entry->flags, "|",
+		  {V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
+		  {V4L2_FWHT_FL_IS_BOTTOM_FIRST, "IS_BOTTOM_FIRST"},
+		  {V4L2_FWHT_FL_IS_ALTERNATE, "IS_ALTERNATE"},
+		  {V4L2_FWHT_FL_IS_BOTTOM_FIELD, "IS_BOTTOM_FIELD"},
+		  {V4L2_FWHT_FL_LUMA_IS_UNCOMPRESSED, "LUMA_IS_UNCOMPRESSED"},
+		  {V4L2_FWHT_FL_CB_IS_UNCOMPRESSED, "CB_IS_UNCOMPRESSED"},
+		  {V4L2_FWHT_FL_CR_IS_UNCOMPRESSED, "CR_IS_UNCOMPRESSED"},
+		  {V4L2_FWHT_FL_ALPHA_IS_UNCOMPRESSED, "ALPHA_IS_UNCOMPRESSED"},
+		  {V4L2_FWHT_FL_I_FRAME, "I_FRAME"},
+		  {V4L2_FWHT_FL_PIXENC_HSV, "PIXENC_HSV"},
+		  {V4L2_FWHT_FL_PIXENC_RGB, "PIXENC_RGB"},
+		  {V4L2_FWHT_FL_PIXENC_YUV, "PIXENC_YUV"}),
+		  __entry->colorspace, __entry->xfer_func, __entry->ycbcr_enc,
+		  __entry->quantization)
+);
+
+DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
+	TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
+	TP_ARGS(p)
+);
+
+/* H264 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
+	TP_fast_assign(__entry->s = *s),
+	TP_printk("\nprofile_idc %u\n"
+		  "constraint_set_flags %s\n"
+		  "level_idc %u\n"
+		  "seq_parameter_set_id %u\n"
+		  "chroma_format_idc %u\n"
+		  "bit_depth_luma_minus8 %u\n"
+		  "bit_depth_chroma_minus8 %u\n"
+		  "log2_max_frame_num_minus4 %u\n"
+		  "pic_order_cnt_type %u\n"
+		  "log2_max_pic_order_cnt_lsb_minus4 %u\n"
+		  "max_num_ref_frames %u\n"
+		  "num_ref_frames_in_pic_order_cnt_cycle %u\n"
+		  "offset_for_ref_frame %s\n"
+		  "offset_for_non_ref_pic %d\n"
+		  "offset_for_top_to_bottom_field %d\n"
+		  "pic_width_in_mbs_minus1 %u\n"
+		  "pic_height_in_map_units_minus1 %u\n"
+		  "flags %s",
+		  __entry->s.profile_idc,
+		  __print_flags(__entry->s.constraint_set_flags, "|",
+		  {V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
+		  {V4L2_H264_SPS_CONSTRAINT_SET1_FLAG, "CONSTRAINT_SET1_FLAG"},
+		  {V4L2_H264_SPS_CONSTRAINT_SET2_FLAG, "CONSTRAINT_SET2_FLAG"},
+		  {V4L2_H264_SPS_CONSTRAINT_SET3_FLAG, "CONSTRAINT_SET3_FLAG"},
+		  {V4L2_H264_SPS_CONSTRAINT_SET4_FLAG, "CONSTRAINT_SET4_FLAG"},
+		  {V4L2_H264_SPS_CONSTRAINT_SET5_FLAG, "CONSTRAINT_SET5_FLAG"}),
+		  __entry->s.level_idc,
+		  __entry->s.seq_parameter_set_id,
+		  __entry->s.chroma_format_idc,
+		  __entry->s.bit_depth_luma_minus8,
+		  __entry->s.bit_depth_chroma_minus8,
+		  __entry->s.log2_max_frame_num_minus4,
+		  __entry->s.pic_order_cnt_type,
+		  __entry->s.log2_max_pic_order_cnt_lsb_minus4,
+		  __entry->s.max_num_ref_frames,
+		  __entry->s.num_ref_frames_in_pic_order_cnt_cycle,
+		  __print_array(__entry->s.offset_for_ref_frame,
+				ARRAY_SIZE(__entry->s.offset_for_ref_frame),
+				sizeof(__entry->s.offset_for_ref_frame[0])),
+		  __entry->s.offset_for_non_ref_pic,
+		  __entry->s.offset_for_top_to_bottom_field,
+		  __entry->s.pic_width_in_mbs_minus1,
+		  __entry->s.pic_height_in_map_units_minus1,
+		  __print_flags(__entry->s.flags, "|",
+		  {V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
+		  {V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS, "QPPRIME_Y_ZERO_TRANSFORM_BYPASS"},
+		  {V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO, "DELTA_PIC_ORDER_ALWAYS_ZERO"},
+		  {V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED, "GAPS_IN_FRAME_NUM_VALUE_ALLOWED"},
+		  {V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY, "FRAME_MBS_ONLY"},
+		  {V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD, "MB_ADAPTIVE_FRAME_FIELD"},
+		  {V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE, "DIRECT_8X8_INFERENCE"}
+		  ))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
+	TP_fast_assign(__entry->p = *p),
+	TP_printk("\npic_parameter_set_id %u\n"
+		  "seq_parameter_set_id %u\n"
+		  "num_slice_groups_minus1 %u\n"
+		  "num_ref_idx_l0_default_active_minus1 %u\n"
+		  "num_ref_idx_l1_default_active_minus1 %u\n"
+		  "weighted_bipred_idc %u\n"
+		  "pic_init_qp_minus26 %d\n"
+		  "pic_init_qs_minus26 %d\n"
+		  "chroma_qp_index_offset %d\n"
+		  "second_chroma_qp_index_offset %d\n"
+		  "flags %s",
+		  __entry->p.pic_parameter_set_id,
+		  __entry->p.seq_parameter_set_id,
+		  __entry->p.num_slice_groups_minus1,
+		  __entry->p.num_ref_idx_l0_default_active_minus1,
+		  __entry->p.num_ref_idx_l1_default_active_minus1,
+		  __entry->p.weighted_bipred_idc,
+		  __entry->p.pic_init_qp_minus26,
+		  __entry->p.pic_init_qs_minus26,
+		  __entry->p.chroma_qp_index_offset,
+		  __entry->p.second_chroma_qp_index_offset,
+		  __print_flags(__entry->p.flags, "|",
+		  {V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE, "ENTROPY_CODING_MODE"},
+		  {V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT, "BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT"},
+		  {V4L2_H264_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
+		  {V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
+		  {V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
+		  {V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT, "REDUNDANT_PIC_CNT_PRESENT"},
+		  {V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE, "TRANSFORM_8X8_MODE"},
+		  {V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT, "SCALING_MATRIX_PRESENT"}
+		  ))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
+	TP_fast_assign(__entry->s = *s),
+	TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->s.scaling_list_4x4,
+				   sizeof(__entry->s.scaling_list_4x4),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->s.scaling_list_8x8,
+				   sizeof(__entry->s.scaling_list_8x8),
+				   false)
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
+	TP_fast_assign(__entry->p = *p),
+	TP_printk("\nluma_log2_weight_denom %u\n"
+		  "chroma_log2_weight_denom %u\n"
+		  "weight_factor[0].luma_weight %s\n"
+		  "weight_factor[0].luma_offset %s\n"
+		  "weight_factor[0].chroma_weight {%s}\n"
+		  "weight_factor[0].chroma_offset {%s}\n"
+		  "weight_factor[1].luma_weight %s\n"
+		  "weight_factor[1].luma_offset %s\n"
+		  "weight_factor[1].chroma_weight {%s}\n"
+		  "weight_factor[1].chroma_offset {%s}\n",
+		  __entry->p.luma_log2_weight_denom,
+		  __entry->p.chroma_log2_weight_denom,
+		  __print_array(__entry->p.weight_factors[0].luma_weight,
+				ARRAY_SIZE(__entry->p.weight_factors[0].luma_weight),
+				sizeof(__entry->p.weight_factors[0].luma_weight[0])),
+		  __print_array(__entry->p.weight_factors[0].luma_offset,
+				ARRAY_SIZE(__entry->p.weight_factors[0].luma_offset),
+				sizeof(__entry->p.weight_factors[0].luma_offset[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.weight_factors[0].chroma_weight,
+				   sizeof(__entry->p.weight_factors[0].chroma_weight),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.weight_factors[0].chroma_offset,
+				   sizeof(__entry->p.weight_factors[0].chroma_offset),
+				   false),
+		  __print_array(__entry->p.weight_factors[1].luma_weight,
+				ARRAY_SIZE(__entry->p.weight_factors[1].luma_weight),
+				sizeof(__entry->p.weight_factors[1].luma_weight[0])),
+		  __print_array(__entry->p.weight_factors[1].luma_offset,
+				ARRAY_SIZE(__entry->p.weight_factors[1].luma_offset),
+				sizeof(__entry->p.weight_factors[1].luma_offset[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.weight_factors[1].chroma_weight,
+				   sizeof(__entry->p.weight_factors[1].chroma_weight),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.weight_factors[1].chroma_offset,
+				   sizeof(__entry->p.weight_factors[1].chroma_offset),
+				   false)
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
+	TP_fast_assign(__entry->s = *s),
+	TP_printk("\nheader_bit_size %u\n"
+		  "first_mb_in_slice %u\n"
+		  "slice_type %s\n"
+		  "colour_plane_id %u\n"
+		  "redundant_pic_cnt %u\n"
+		  "cabac_init_idc %u\n"
+		  "slice_qp_delta %d\n"
+		  "slice_qs_delta %d\n"
+		  "disable_deblocking_filter_idc %u\n"
+		  "slice_alpha_c0_offset_div2 %u\n"
+		  "slice_beta_offset_div2 %u\n"
+		  "num_ref_idx_l0_active_minus1 %u\n"
+		  "num_ref_idx_l1_active_minus1 %u\n"
+		  "flags %s",
+		  __entry->s.header_bit_size,
+		  __entry->s.first_mb_in_slice,
+		  __print_symbolic(__entry->s.slice_type,
+		  {V4L2_H264_SLICE_TYPE_P, "P"},
+		  {V4L2_H264_SLICE_TYPE_B, "B"},
+		  {V4L2_H264_SLICE_TYPE_I, "I"},
+		  {V4L2_H264_SLICE_TYPE_SP, "SP"},
+		  {V4L2_H264_SLICE_TYPE_SI, "SI"}),
+		  __entry->s.colour_plane_id,
+		  __entry->s.redundant_pic_cnt,
+		  __entry->s.cabac_init_idc,
+		  __entry->s.slice_qp_delta,
+		  __entry->s.slice_qs_delta,
+		  __entry->s.disable_deblocking_filter_idc,
+		  __entry->s.slice_alpha_c0_offset_div2,
+		  __entry->s.slice_beta_offset_div2,
+		  __entry->s.num_ref_idx_l0_active_minus1,
+		  __entry->s.num_ref_idx_l1_active_minus1,
+		  __print_flags(__entry->s.flags, "|",
+		  {V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED, "DIRECT_SPATIAL_MV_PRED"},
+		  {V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH, "SP_FOR_SWITCH"})
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
+	TP_PROTO(const struct v4l2_h264_reference *r, int i),
+	TP_ARGS(r, i),
+	TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
+			 __field(int, i)),
+	TP_fast_assign(__entry->r = *r; __entry->i = i;),
+	TP_printk("[%d]: fields %s index %u",
+		  __entry->i,
+		  __print_flags(__entry->r.fields, "|",
+		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
+		  {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
+		  {V4L2_H264_FRAME_REF, "FRAME_REF"}),
+		  __entry->r.index
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
+	TP_ARGS(d),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
+	TP_fast_assign(__entry->d = *d),
+	TP_printk("\nnal_ref_idc %u\n"
+		  "frame_num %u\n"
+		  "top_field_order_cnt %d\n"
+		  "bottom_field_order_cnt %d\n"
+		  "idr_pic_id %u\n"
+		  "pic_order_cnt_lsb %u\n"
+		  "delta_pic_order_cnt_bottom %d\n"
+		  "delta_pic_order_cnt0 %d\n"
+		  "delta_pic_order_cnt1 %d\n"
+		  "dec_ref_pic_marking_bit_size %u\n"
+		  "pic_order_cnt_bit_size %u\n"
+		  "slice_group_change_cycle %u\n"
+		  "flags %s\n",
+		  __entry->d.nal_ref_idc,
+		  __entry->d.frame_num,
+		  __entry->d.top_field_order_cnt,
+		  __entry->d.bottom_field_order_cnt,
+		  __entry->d.idr_pic_id,
+		  __entry->d.pic_order_cnt_lsb,
+		  __entry->d.delta_pic_order_cnt_bottom,
+		  __entry->d.delta_pic_order_cnt0,
+		  __entry->d.delta_pic_order_cnt1,
+		  __entry->d.dec_ref_pic_marking_bit_size,
+		  __entry->d.pic_order_cnt_bit_size,
+		  __entry->d.slice_group_change_cycle,
+		  __print_flags(__entry->d.flags, "|",
+		  {V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
+		  {V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC, "FIELD_PIC"},
+		  {V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD, "BOTTOM_FIELD"},
+		  {V4L2_H264_DECODE_PARAM_FLAG_PFRAME, "PFRAME"},
+		  {V4L2_H264_DECODE_PARAM_FLAG_BFRAME, "BFRAME"})
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
+	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
+	TP_ARGS(e, i),
+	TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
+			 __field(int, i)),
+	TP_fast_assign(__entry->e = *e; __entry->i = i;),
+	TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
+		  "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
+		  __entry->i,
+		  __entry->e.reference_ts,
+		  __entry->e.pic_num,
+		  __entry->e.frame_num,
+		  __print_flags(__entry->e.fields, "|",
+		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
+		  {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
+		  {V4L2_H264_FRAME_REF, "FRAME_REF"}),
+		  __entry->e.top_field_order_cnt,
+		  __entry->e.bottom_field_order_cnt,
+		  __print_flags(__entry->e.flags, "|",
+		  {V4L2_H264_DPB_ENTRY_FLAG_VALID, "VALID"},
+		  {V4L2_H264_DPB_ENTRY_FLAG_ACTIVE, "ACTIVE"},
+		  {V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM, "LONG_TERM"},
+		  {V4L2_H264_DPB_ENTRY_FLAG_FIELD, "FIELD"})
+
+	)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_sps_tmpl, v4l2_ctrl_h264_sps,
+	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_pps_tmpl, v4l2_ctrl_h264_pps,
+	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
+	TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_scaling_matrix_tmpl, v4l2_ctrl_h264_scaling_matrix,
+	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_pred_weights_tmpl, v4l2_ctrl_h264_pred_weights,
+	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
+	TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_slice_params_tmpl, v4l2_ctrl_h264_slice_params,
+	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list0,
+	TP_PROTO(const struct v4l2_h264_reference *r, int i),
+	TP_ARGS(r, i)
+);
+
+DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list1,
+	TP_PROTO(const struct v4l2_h264_reference *r, int i),
+	TP_ARGS(r, i)
+);
+
+DEFINE_EVENT(v4l2_ctrl_h264_decode_params_tmpl, v4l2_ctrl_h264_decode_params,
+	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
+	TP_ARGS(d)
+);
+
+DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
+	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
+	TP_ARGS(e, i)
+);
+
+/* HEVC controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
+	TP_fast_assign(__entry->s = *s),
+	TP_printk("\nvideo_parameter_set_id %u\n"
+		  "seq_parameter_set_id %u\n"
+		  "pic_width_in_luma_samples %u\n"
+		  "pic_height_in_luma_samples %u\n"
+		  "bit_depth_luma_minus8 %u\n"
+		  "bit_depth_chroma_minus8 %u\n"
+		  "log2_max_pic_order_cnt_lsb_minus4 %u\n"
+		  "sps_max_dec_pic_buffering_minus1 %u\n"
+		  "sps_max_num_reorder_pics %u\n"
+		  "sps_max_latency_increase_plus1 %u\n"
+		  "log2_min_luma_coding_block_size_minus3 %u\n"
+		  "log2_diff_max_min_luma_coding_block_size %u\n"
+		  "log2_min_luma_transform_block_size_minus2 %u\n"
+		  "log2_diff_max_min_luma_transform_block_size %u\n"
+		  "max_transform_hierarchy_depth_inter %u\n"
+		  "max_transform_hierarchy_depth_intra %u\n"
+		  "pcm_sample_bit_depth_luma_minus1 %u\n"
+		  "pcm_sample_bit_depth_chroma_minus1 %u\n"
+		  "log2_min_pcm_luma_coding_block_size_minus3 %u\n"
+		  "log2_diff_max_min_pcm_luma_coding_block_size %u\n"
+		  "num_short_term_ref_pic_sets %u\n"
+		  "num_long_term_ref_pics_sps %u\n"
+		  "chroma_format_idc %u\n"
+		  "sps_max_sub_layers_minus1 %u\n"
+		  "flags %s",
+		  __entry->s.video_parameter_set_id,
+		  __entry->s.seq_parameter_set_id,
+		  __entry->s.pic_width_in_luma_samples,
+		  __entry->s.pic_height_in_luma_samples,
+		  __entry->s.bit_depth_luma_minus8,
+		  __entry->s.bit_depth_chroma_minus8,
+		  __entry->s.log2_max_pic_order_cnt_lsb_minus4,
+		  __entry->s.sps_max_dec_pic_buffering_minus1,
+		  __entry->s.sps_max_num_reorder_pics,
+		  __entry->s.sps_max_latency_increase_plus1,
+		  __entry->s.log2_min_luma_coding_block_size_minus3,
+		  __entry->s.log2_diff_max_min_luma_coding_block_size,
+		  __entry->s.log2_min_luma_transform_block_size_minus2,
+		  __entry->s.log2_diff_max_min_luma_transform_block_size,
+		  __entry->s.max_transform_hierarchy_depth_inter,
+		  __entry->s.max_transform_hierarchy_depth_intra,
+		  __entry->s.pcm_sample_bit_depth_luma_minus1,
+		  __entry->s.pcm_sample_bit_depth_chroma_minus1,
+		  __entry->s.log2_min_pcm_luma_coding_block_size_minus3,
+		  __entry->s.log2_diff_max_min_pcm_luma_coding_block_size,
+		  __entry->s.num_short_term_ref_pic_sets,
+		  __entry->s.num_long_term_ref_pics_sps,
+		  __entry->s.chroma_format_idc,
+		  __entry->s.sps_max_sub_layers_minus1,
+		  __print_flags(__entry->s.flags, "|",
+		  {V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
+		  {V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED, "SCALING_LIST_ENABLED"},
+		  {V4L2_HEVC_SPS_FLAG_AMP_ENABLED, "AMP_ENABLED"},
+		  {V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET, "SAMPLE_ADAPTIVE_OFFSET"},
+		  {V4L2_HEVC_SPS_FLAG_PCM_ENABLED, "PCM_ENABLED"},
+		  {V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED, "V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED"},
+		  {V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT, "LONG_TERM_REF_PICS_PRESENT"},
+		  {V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED, "TEMPORAL_MVP_ENABLED"},
+		  {V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED, "STRONG_INTRA_SMOOTHING_ENABLED"}
+	))
+
+);
+
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
+	TP_fast_assign(__entry->p = *p),
+	TP_printk("\npic_parameter_set_id %u\n"
+		  "num_extra_slice_header_bits %u\n"
+		  "num_ref_idx_l0_default_active_minus1 %u\n"
+		  "num_ref_idx_l1_default_active_minus1 %u\n"
+		  "init_qp_minus26 %d\n"
+		  "diff_cu_qp_delta_depth %u\n"
+		  "pps_cb_qp_offset %d\n"
+		  "pps_cr_qp_offset %d\n"
+		  "num_tile_columns_minus1 %d\n"
+		  "num_tile_rows_minus1 %d\n"
+		  "column_width_minus1 %s\n"
+		  "row_height_minus1 %s\n"
+		  "pps_beta_offset_div2 %d\n"
+		  "pps_tc_offset_div2 %d\n"
+		  "log2_parallel_merge_level_minus2 %u\n"
+		  "flags %s",
+		  __entry->p.pic_parameter_set_id,
+		  __entry->p.num_extra_slice_header_bits,
+		  __entry->p.num_ref_idx_l0_default_active_minus1,
+		  __entry->p.num_ref_idx_l1_default_active_minus1,
+		  __entry->p.init_qp_minus26,
+		  __entry->p.diff_cu_qp_delta_depth,
+		  __entry->p.pps_cb_qp_offset,
+		  __entry->p.pps_cr_qp_offset,
+		  __entry->p.num_tile_columns_minus1,
+		  __entry->p.num_tile_rows_minus1,
+		  __print_array(__entry->p.column_width_minus1,
+				ARRAY_SIZE(__entry->p.column_width_minus1),
+				sizeof(__entry->p.column_width_minus1[0])),
+		  __print_array(__entry->p.row_height_minus1,
+				ARRAY_SIZE(__entry->p.row_height_minus1),
+				sizeof(__entry->p.row_height_minus1[0])),
+		  __entry->p.pps_beta_offset_div2,
+		  __entry->p.pps_tc_offset_div2,
+		  __entry->p.log2_parallel_merge_level_minus2,
+		  __print_flags(__entry->p.flags, "|",
+		  {V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED, "DEPENDENT_SLICE_SEGMENT_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT, "OUTPUT_FLAG_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED, "SIGN_DATA_HIDING_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT, "CABAC_INIT_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
+		  {V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED, "CU_QP_DELTA_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT, "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
+		  {V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED, "WEIGHTED_BIPRED"},
+		  {V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED, "TRANSQUANT_BYPASS_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_TILES_ENABLED, "TILES_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED, "ENTROPY_CODING_SYNC_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED, "LOOP_FILTER_ACROSS_TILES_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED, "PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED, "DEBLOCKING_FILTER_OVERRIDE_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER, "DISABLE_DEBLOCKING_FILTER"},
+		  {V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT, "LISTS_MODIFICATION_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT, "SLICE_SEGMENT_HEADER_EXTENSION_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_UNIFORM_SPACING, "UNIFORM_SPACING"}
+	))
+
+);
+
+
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
+	TP_fast_assign(__entry->s = *s),
+	TP_printk("\nbit_size %u\n"
+		  "data_byte_offset %u\n"
+		  "num_entry_point_offsets %u\n"
+		  "nal_unit_type %u\n"
+		  "nuh_temporal_id_plus1 %u\n"
+		  "slice_type %u\n"
+		  "colour_plane_id %u\n"
+		  "slice_pic_order_cnt %d\n"
+		  "num_ref_idx_l0_active_minus1 %u\n"
+		  "num_ref_idx_l1_active_minus1 %u\n"
+		  "collocated_ref_idx %u\n"
+		  "five_minus_max_num_merge_cand %u\n"
+		  "slice_qp_delta %d\n"
+		  "slice_cb_qp_offset %d\n"
+		  "slice_cr_qp_offset %d\n"
+		  "slice_act_y_qp_offset %d\n"
+		  "slice_act_cb_qp_offset %d\n"
+		  "slice_act_cr_qp_offset %d\n"
+		  "slice_beta_offset_div2 %d\n"
+		  "slice_tc_offset_div2 %d\n"
+		  "pic_struct %u\n"
+		  "slice_segment_addr %u\n"
+		  "ref_idx_l0 %s\n"
+		  "ref_idx_l1 %s\n"
+		  "short_term_ref_pic_set_size %u\n"
+		  "long_term_ref_pic_set_size %u\n"
+		  "flags %s",
+		  __entry->s.bit_size,
+		  __entry->s.data_byte_offset,
+		  __entry->s.num_entry_point_offsets,
+		  __entry->s.nal_unit_type,
+		  __entry->s.nuh_temporal_id_plus1,
+		  __entry->s.slice_type,
+		  __entry->s.colour_plane_id,
+		  __entry->s.slice_pic_order_cnt,
+		  __entry->s.num_ref_idx_l0_active_minus1,
+		  __entry->s.num_ref_idx_l1_active_minus1,
+		  __entry->s.collocated_ref_idx,
+		  __entry->s.five_minus_max_num_merge_cand,
+		  __entry->s.slice_qp_delta,
+		  __entry->s.slice_cb_qp_offset,
+		  __entry->s.slice_cr_qp_offset,
+		  __entry->s.slice_act_y_qp_offset,
+		  __entry->s.slice_act_cb_qp_offset,
+		  __entry->s.slice_act_cr_qp_offset,
+		  __entry->s.slice_beta_offset_div2,
+		  __entry->s.slice_tc_offset_div2,
+		  __entry->s.pic_struct,
+		  __entry->s.slice_segment_addr,
+		  __print_array(__entry->s.ref_idx_l0,
+				ARRAY_SIZE(__entry->s.ref_idx_l0),
+				sizeof(__entry->s.ref_idx_l0[0])),
+		  __print_array(__entry->s.ref_idx_l1,
+				ARRAY_SIZE(__entry->s.ref_idx_l1),
+				sizeof(__entry->s.ref_idx_l1[0])),
+		  __entry->s.short_term_ref_pic_set_size,
+		  __entry->s.long_term_ref_pic_set_size,
+		  __print_flags(__entry->s.flags, "|",
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA, "SLICE_SAO_LUMA"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA, "SLICE_SAO_CHROMA"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED, "SLICE_TEMPORAL_MVP_ENABLED"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO, "MVD_L1_ZERO"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT, "CABAC_INIT"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0, "COLLOCATED_FROM_L0"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV, "USE_INTEGER_MV"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED, "SLICE_DEBLOCKING_FILTER_DISABLED"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED, "SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENT, "DEPENDENT_SLICE_SEGMENT"}
+
+	))
+);
+
+DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
+	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
+	TP_fast_assign(__entry->p = *p),
+	TP_printk("\ndelta_luma_weight_l0 %s\n"
+		  "luma_offset_l0 %s\n"
+		  "delta_chroma_weight_l0 {%s}\n"
+		  "chroma_offset_l0 {%s}\n"
+		  "delta_luma_weight_l1 %s\n"
+		  "luma_offset_l1 %s\n"
+		  "delta_chroma_weight_l1 {%s}\n"
+		  "chroma_offset_l1 {%s}\n"
+		  "luma_log2_weight_denom %d\n"
+		  "delta_chroma_log2_weight_denom %d\n",
+		  __print_array(__entry->p.delta_luma_weight_l0,
+				ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
+				sizeof(__entry->p.delta_luma_weight_l0[0])),
+		  __print_array(__entry->p.luma_offset_l0,
+				ARRAY_SIZE(__entry->p.luma_offset_l0),
+				sizeof(__entry->p.luma_offset_l0[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.delta_chroma_weight_l0,
+				   sizeof(__entry->p.delta_chroma_weight_l0),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.chroma_offset_l0,
+				   sizeof(__entry->p.chroma_offset_l0),
+				   false),
+		  __print_array(__entry->p.delta_luma_weight_l1,
+				ARRAY_SIZE(__entry->p.delta_luma_weight_l1),
+				sizeof(__entry->p.delta_luma_weight_l1[0])),
+		  __print_array(__entry->p.luma_offset_l1,
+				ARRAY_SIZE(__entry->p.luma_offset_l1),
+				sizeof(__entry->p.luma_offset_l1[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.delta_chroma_weight_l1,
+				   sizeof(__entry->p.delta_chroma_weight_l1),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.chroma_offset_l1,
+				   sizeof(__entry->p.chroma_offset_l1),
+				   false),
+		__entry->p.luma_log2_weight_denom,
+		__entry->p.delta_chroma_log2_weight_denom
+
+	))
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
+	TP_fast_assign(__entry->s = *s),
+	TP_printk("\nscaling_list_4x4 {%s}\n"
+		  "scaling_list_8x8 {%s}\n"
+		  "scaling_list_16x16 {%s}\n"
+		  "scaling_list_32x32 {%s}\n"
+		  "scaling_list_dc_coef_16x16 %s\n"
+		  "scaling_list_dc_coef_32x32 %s\n",
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->s.scaling_list_4x4,
+				   sizeof(__entry->s.scaling_list_4x4),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->s.scaling_list_8x8,
+				   sizeof(__entry->s.scaling_list_8x8),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->s.scaling_list_16x16,
+				   sizeof(__entry->s.scaling_list_16x16),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->s.scaling_list_32x32,
+				   sizeof(__entry->s.scaling_list_32x32),
+				   false),
+		  __print_array(__entry->s.scaling_list_dc_coef_16x16,
+				ARRAY_SIZE(__entry->s.scaling_list_dc_coef_16x16),
+				sizeof(__entry->s.scaling_list_dc_coef_16x16[0])),
+		  __print_array(__entry->s.scaling_list_dc_coef_32x32,
+				ARRAY_SIZE(__entry->s.scaling_list_dc_coef_32x32),
+				sizeof(__entry->s.scaling_list_dc_coef_32x32[0]))
+	))
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
+	TP_ARGS(d),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
+	TP_fast_assign(__entry->d = *d),
+	TP_printk("\npic_order_cnt_val %d\n"
+		  "short_term_ref_pic_set_size %u\n"
+		  "long_term_ref_pic_set_size %u\n"
+		  "num_active_dpb_entries %u\n"
+		  "num_poc_st_curr_before %u\n"
+		  "num_poc_st_curr_after %u\n"
+		  "num_poc_lt_curr %u\n"
+		  "poc_st_curr_before %s\n"
+		  "poc_st_curr_after %s\n"
+		  "poc_lt_curr %s\n"
+		  "flags %s",
+		  __entry->d.pic_order_cnt_val,
+		  __entry->d.short_term_ref_pic_set_size,
+		  __entry->d.long_term_ref_pic_set_size,
+		  __entry->d.num_active_dpb_entries,
+		  __entry->d.num_poc_st_curr_before,
+		  __entry->d.num_poc_st_curr_after,
+		  __entry->d.num_poc_lt_curr,
+		  __print_array(__entry->d.poc_st_curr_before,
+				ARRAY_SIZE(__entry->d.poc_st_curr_before),
+				sizeof(__entry->d.poc_st_curr_before[0])),
+		  __print_array(__entry->d.poc_st_curr_after,
+				ARRAY_SIZE(__entry->d.poc_st_curr_after),
+				sizeof(__entry->d.poc_st_curr_after[0])),
+		  __print_array(__entry->d.poc_lt_curr,
+				ARRAY_SIZE(__entry->d.poc_lt_curr),
+				sizeof(__entry->d.poc_lt_curr[0])),
+		  __print_flags(__entry->d.flags, "|",
+		  {V4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PIC, "IRAP_PIC"},
+		  {V4L2_HEVC_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
+		  {V4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIOR, "NO_OUTPUT_OF_PRIOR"}
+	))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+	TP_ARGS(lt),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
+	TP_fast_assign(__entry->lt = *lt),
+	TP_printk("\nflags %s\n"
+		  "lt_ref_pic_poc_lsb_sps %x\n",
+		  __print_flags(__entry->lt.flags, "|",
+		  {V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
+		  ),
+		  __entry->lt.lt_ref_pic_poc_lsb_sps
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+	TP_ARGS(st),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
+	TP_fast_assign(__entry->st = *st),
+	TP_printk("\nflags %s\n"
+		  "delta_idx_minus1: %u\n"
+		  "delta_rps_sign: %u\n"
+		  "abs_delta_rps_minus1: %u\n"
+		  "num_negative_pics: %u\n"
+		  "num_positive_pics: %u\n"
+		  "used_by_curr_pic: %08x\n"
+		  "use_delta_flag: %08x\n"
+		  "delta_poc_s0_minus1: %s\n"
+		  "delta_poc_s1_minus1: %s\n",
+		  __print_flags(__entry->st.flags, "|",
+		  {V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
+		  ),
+		  __entry->st.delta_idx_minus1,
+		  __entry->st.delta_rps_sign,
+		  __entry->st.abs_delta_rps_minus1,
+		  __entry->st.num_negative_pics,
+		  __entry->st.num_positive_pics,
+		  __entry->st.used_by_curr_pic,
+		  __entry->st.use_delta_flag,
+		  __print_array(__entry->st.delta_poc_s0_minus1,
+				ARRAY_SIZE(__entry->st.delta_poc_s0_minus1),
+				sizeof(__entry->st.delta_poc_s0_minus1[0])),
+		  __print_array(__entry->st.delta_poc_s1_minus1,
+				ARRAY_SIZE(__entry->st.delta_poc_s1_minus1),
+				sizeof(__entry->st.delta_poc_s1_minus1[0]))
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
+	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
+	TP_ARGS(e),
+	TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
+	TP_fast_assign(__entry->e = *e),
+	TP_printk("\ntimestamp %llu\n"
+		  "flags %s\n"
+		  "field_pic %u\n"
+		  "pic_order_cnt_val %d\n",
+		__entry->e.timestamp,
+		__print_flags(__entry->e.flags, "|",
+		{V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
+		  ),
+		__entry->e.field_pic,
+		__entry->e.pic_order_cnt_val
+	))
+
+DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
+	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_pps_tmpl, v4l2_ctrl_hevc_pps,
+	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
+	TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_slice_params_tmpl, v4l2_ctrl_hevc_slice_params,
+	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_hevc_pred_weight_table_tmpl, v4l2_hevc_pred_weight_table,
+	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
+	TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_scaling_matrix_tmpl, v4l2_ctrl_hevc_scaling_matrix,
+	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_decode_params_tmpl, v4l2_ctrl_hevc_decode_params,
+	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
+	TP_ARGS(d)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl, v4l2_ctrl_hevc_ext_sps_lt_rps,
+	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+	TP_ARGS(lt)
+);
+
+DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl, v4l2_ctrl_hevc_ext_sps_st_rps,
+	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+	TP_ARGS(st)
+);
+
+DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
+	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
+	TP_ARGS(e)
+);
+
+/* MPEG2 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
+	TP_ARGS(s),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
+	TP_fast_assign(__entry->s = *s;),
+	TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
+		  "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
+		  __entry->s.horizontal_size,
+		  __entry->s.vertical_size,
+		  __entry->s.vbv_buffer_size,
+		  __entry->s.profile_and_level_indication,
+		  __entry->s.chroma_format,
+		  __print_flags(__entry->s.flags, "|",
+		  {V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE, "PROGRESSIVE"})
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
+	TP_fast_assign(__entry->p = *p;),
+	TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
+		  "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
+		  __entry->p.backward_ref_ts,
+		  __entry->p.forward_ref_ts,
+		  __print_flags(__entry->p.flags, "|",
+		  {V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST, "TOP_FIELD_FIRST"},
+		  {V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT, "FRAME_PRED_DCT"},
+		  {V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV, "CONCEALMENT_MV"},
+		  {V4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPE, "Q_SCALE_TYPE"},
+		  {V4L2_MPEG2_PIC_FLAG_INTRA_VLC, "INTA_VLC"},
+		  {V4L2_MPEG2_PIC_FLAG_ALT_SCAN, "ALT_SCAN"},
+		  {V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST, "REPEAT_FIRST"},
+		  {V4L2_MPEG2_PIC_FLAG_PROGRESSIVE, "PROGRESSIVE"}),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.f_code,
+				   sizeof(__entry->p.f_code),
+				   false),
+		  __entry->p.picture_coding_type,
+		  __entry->p.picture_structure,
+		  __entry->p.intra_dc_precision
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
+	TP_ARGS(q),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
+	TP_fast_assign(__entry->q = *q;),
+	TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
+		  "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
+		  __print_array(__entry->q.intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
+				sizeof(__entry->q.intra_quantiser_matrix[0])),
+		  __print_array(__entry->q.non_intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->q.non_intra_quantiser_matrix),
+				sizeof(__entry->q.non_intra_quantiser_matrix[0])),
+		  __print_array(__entry->q.chroma_intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->q.chroma_intra_quantiser_matrix),
+				sizeof(__entry->q.chroma_intra_quantiser_matrix[0])),
+		  __print_array(__entry->q.chroma_non_intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->q.chroma_non_intra_quantiser_matrix),
+				sizeof(__entry->q.chroma_non_intra_quantiser_matrix[0]))
+		  )
+)
+
+DEFINE_EVENT(v4l2_ctrl_mpeg2_seq_tmpl, v4l2_ctrl_mpeg2_sequence,
+	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
+	TP_ARGS(s)
+);
+
+DEFINE_EVENT(v4l2_ctrl_mpeg2_pic_tmpl, v4l2_ctrl_mpeg2_picture,
+	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
+	TP_ARGS(p)
+);
+
+DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
+	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
+	TP_ARGS(q)
+);
+
+/* VP8 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(f),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
+	TP_fast_assign(__entry->f = *f;),
+	TP_printk("\nentropy.coeff_probs {%s}\n"
+		  "entropy.y_mode_probs %s\n"
+		  "entropy.uv_mode_probs %s\n"
+		  "entropy.mv_probs {%s}",
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->f.entropy.coeff_probs,
+				   sizeof(__entry->f.entropy.coeff_probs),
+				   false),
+		  __print_array(__entry->f.entropy.y_mode_probs,
+				ARRAY_SIZE(__entry->f.entropy.y_mode_probs),
+				sizeof(__entry->f.entropy.y_mode_probs[0])),
+		  __print_array(__entry->f.entropy.uv_mode_probs,
+				ARRAY_SIZE(__entry->f.entropy.uv_mode_probs),
+				sizeof(__entry->f.entropy.uv_mode_probs[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->f.entropy.mv_probs,
+				   sizeof(__entry->f.entropy.mv_probs),
+				   false)
+		  )
+)
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(f),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
+	TP_fast_assign(__entry->f = *f;),
+	TP_printk("\nsegment.quant_update %s\n"
+		  "segment.lf_update %s\n"
+		  "segment.segment_probs %s\n"
+		  "segment.flags %s\n"
+		  "lf.ref_frm_delta %s\n"
+		  "lf.mb_mode_delta %s\n"
+		  "lf.sharpness_level %u\n"
+		  "lf.level %u\n"
+		  "lf.flags %s\n"
+		  "quant.y_ac_qi %u\n"
+		  "quant.y_dc_delta %d\n"
+		  "quant.y2_dc_delta %d\n"
+		  "quant.y2_ac_delta %d\n"
+		  "quant.uv_dc_delta %d\n"
+		  "quant.uv_ac_delta %d\n"
+		  "coder_state.range %u\n"
+		  "coder_state.value %u\n"
+		  "coder_state.bit_count %u\n"
+		  "width %u\n"
+		  "height %u\n"
+		  "horizontal_scale %u\n"
+		  "vertical_scale %u\n"
+		  "version %u\n"
+		  "prob_skip_false %u\n"
+		  "prob_intra %u\n"
+		  "prob_last %u\n"
+		  "prob_gf %u\n"
+		  "num_dct_parts %u\n"
+		  "first_part_size %u\n"
+		  "first_part_header_bits %u\n"
+		  "dct_part_sizes %s\n"
+		  "last_frame_ts %llu\n"
+		  "golden_frame_ts %llu\n"
+		  "alt_frame_ts %llu\n"
+		  "flags %s",
+		  __print_array(__entry->f.segment.quant_update,
+				ARRAY_SIZE(__entry->f.segment.quant_update),
+				sizeof(__entry->f.segment.quant_update[0])),
+		  __print_array(__entry->f.segment.lf_update,
+				ARRAY_SIZE(__entry->f.segment.lf_update),
+				sizeof(__entry->f.segment.lf_update[0])),
+		  __print_array(__entry->f.segment.segment_probs,
+				ARRAY_SIZE(__entry->f.segment.segment_probs),
+				sizeof(__entry->f.segment.segment_probs[0])),
+		  __print_flags(__entry->f.segment.flags, "|",
+		  {V4L2_VP8_SEGMENT_FLAG_ENABLED, "SEGMENT_ENABLED"},
+		  {V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP, "SEGMENT_UPDATE_MAP"},
+		  {V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA, "SEGMENT_UPDATE_FEATURE_DATA"},
+		  {V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE, "SEGMENT_DELTA_VALUE_MODE"}),
+		  __print_array(__entry->f.lf.ref_frm_delta,
+				ARRAY_SIZE(__entry->f.lf.ref_frm_delta),
+				sizeof(__entry->f.lf.ref_frm_delta[0])),
+		  __print_array(__entry->f.lf.mb_mode_delta,
+				ARRAY_SIZE(__entry->f.lf.mb_mode_delta),
+				sizeof(__entry->f.lf.mb_mode_delta[0])),
+		  __entry->f.lf.sharpness_level,
+		  __entry->f.lf.level,
+		  __print_flags(__entry->f.lf.flags, "|",
+		  {V4L2_VP8_LF_ADJ_ENABLE, "LF_ADJ_ENABLED"},
+		  {V4L2_VP8_LF_DELTA_UPDATE, "LF_DELTA_UPDATE"},
+		  {V4L2_VP8_LF_FILTER_TYPE_SIMPLE, "LF_FILTER_TYPE_SIMPLE"}),
+		  __entry->f.quant.y_ac_qi,
+		  __entry->f.quant.y_dc_delta,
+		  __entry->f.quant.y2_dc_delta,
+		  __entry->f.quant.y2_ac_delta,
+		  __entry->f.quant.uv_dc_delta,
+		  __entry->f.quant.uv_ac_delta,
+		  __entry->f.coder_state.range,
+		  __entry->f.coder_state.value,
+		  __entry->f.coder_state.bit_count,
+		  __entry->f.width,
+		  __entry->f.height,
+		  __entry->f.horizontal_scale,
+		  __entry->f.vertical_scale,
+		  __entry->f.version,
+		  __entry->f.prob_skip_false,
+		  __entry->f.prob_intra,
+		  __entry->f.prob_last,
+		  __entry->f.prob_gf,
+		  __entry->f.num_dct_parts,
+		  __entry->f.first_part_size,
+		  __entry->f.first_part_header_bits,
+		  __print_array(__entry->f.dct_part_sizes,
+				ARRAY_SIZE(__entry->f.dct_part_sizes),
+				sizeof(__entry->f.dct_part_sizes[0])),
+		  __entry->f.last_frame_ts,
+		  __entry->f.golden_frame_ts,
+		  __entry->f.alt_frame_ts,
+		  __print_flags(__entry->f.flags, "|",
+		  {V4L2_VP8_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
+		  {V4L2_VP8_FRAME_FLAG_EXPERIMENTAL, "EXPERIMENTAL"},
+		  {V4L2_VP8_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
+		  {V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF, "MB_NO_SKIP_COEFF"},
+		  {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
+		  {V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"})
+		  )
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp8_frame_tmpl, v4l2_ctrl_vp8_frame,
+	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(f)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
+	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(f)
+);
+
+/* VP9 controls */
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
+	TP_ARGS(f),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
+	TP_fast_assign(__entry->f = *f;),
+	TP_printk("\nlf.ref_deltas %s\n"
+		  "lf.mode_deltas %s\n"
+		  "lf.level %u\n"
+		  "lf.sharpness %u\n"
+		  "lf.flags %s\n"
+		  "quant.base_q_idx %u\n"
+		  "quant.delta_q_y_dc %d\n"
+		  "quant.delta_q_uv_dc %d\n"
+		  "quant.delta_q_uv_ac %d\n"
+		  "seg.feature_data {%s}\n"
+		  "seg.feature_enabled %s\n"
+		  "seg.tree_probs %s\n"
+		  "seg.pred_probs %s\n"
+		  "seg.flags %s\n"
+		  "flags %s\n"
+		  "compressed_header_size %u\n"
+		  "uncompressed_header_size %u\n"
+		  "frame_width_minus_1 %u\n"
+		  "frame_height_minus_1 %u\n"
+		  "render_width_minus_1 %u\n"
+		  "render_height_minus_1 %u\n"
+		  "last_frame_ts %llu\n"
+		  "golden_frame_ts %llu\n"
+		  "alt_frame_ts %llu\n"
+		  "ref_frame_sign_bias %s\n"
+		  "reset_frame_context %s\n"
+		  "frame_context_idx %u\n"
+		  "profile %u\n"
+		  "bit_depth %u\n"
+		  "interpolation_filter %s\n"
+		  "tile_cols_log2 %u\n"
+		  "tile_rows_log_2 %u\n"
+		  "reference_mode %s\n",
+		  __print_array(__entry->f.lf.ref_deltas,
+				ARRAY_SIZE(__entry->f.lf.ref_deltas),
+				sizeof(__entry->f.lf.ref_deltas[0])),
+		  __print_array(__entry->f.lf.mode_deltas,
+				ARRAY_SIZE(__entry->f.lf.mode_deltas),
+				sizeof(__entry->f.lf.mode_deltas[0])),
+		  __entry->f.lf.level,
+		  __entry->f.lf.sharpness,
+		  __print_flags(__entry->f.lf.flags, "|",
+		  {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
+		  {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"}),
+		  __entry->f.quant.base_q_idx,
+		  __entry->f.quant.delta_q_y_dc,
+		  __entry->f.quant.delta_q_uv_dc,
+		  __entry->f.quant.delta_q_uv_ac,
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->f.seg.feature_data,
+				   sizeof(__entry->f.seg.feature_data),
+				   false),
+		  __print_array(__entry->f.seg.feature_enabled,
+				ARRAY_SIZE(__entry->f.seg.feature_enabled),
+				sizeof(__entry->f.seg.feature_enabled[0])),
+		  __print_array(__entry->f.seg.tree_probs,
+				ARRAY_SIZE(__entry->f.seg.tree_probs),
+				sizeof(__entry->f.seg.tree_probs[0])),
+		  __print_array(__entry->f.seg.pred_probs,
+				ARRAY_SIZE(__entry->f.seg.pred_probs),
+				sizeof(__entry->f.seg.pred_probs[0])),
+		  __print_flags(__entry->f.seg.flags, "|",
+		  {V4L2_VP9_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
+		  {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
+		  {V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
+		  {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
+		  {V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE, "ABS_OR_DELTA_UPDATE"}),
+		  __print_flags(__entry->f.flags, "|",
+		  {V4L2_VP9_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
+		  {V4L2_VP9_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
+		  {V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT, "ERROR_RESILIENT"},
+		  {V4L2_VP9_FRAME_FLAG_INTRA_ONLY, "INTRA_ONLY"},
+		  {V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV, "ALLOW_HIGH_PREC_MV"},
+		  {V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX, "REFRESH_FRAME_CTX"},
+		  {V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE, "PARALLEL_DEC_MODE"},
+		  {V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING, "X_SUBSAMPLING"},
+		  {V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING, "Y_SUBSAMPLING"},
+		  {V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING, "COLOR_RANGE_FULL_SWING"}),
+		  __entry->f.compressed_header_size,
+		  __entry->f.uncompressed_header_size,
+		  __entry->f.frame_width_minus_1,
+		  __entry->f.frame_height_minus_1,
+		  __entry->f.render_width_minus_1,
+		  __entry->f.render_height_minus_1,
+		  __entry->f.last_frame_ts,
+		  __entry->f.golden_frame_ts,
+		  __entry->f.alt_frame_ts,
+		  __print_symbolic(__entry->f.ref_frame_sign_bias,
+		  {V4L2_VP9_SIGN_BIAS_LAST, "SIGN_BIAS_LAST"},
+		  {V4L2_VP9_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
+		  {V4L2_VP9_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"}),
+		  __print_symbolic(__entry->f.reset_frame_context,
+		  {V4L2_VP9_RESET_FRAME_CTX_NONE, "RESET_FRAME_CTX_NONE"},
+		  {V4L2_VP9_RESET_FRAME_CTX_SPEC, "RESET_FRAME_CTX_SPEC"},
+		  {V4L2_VP9_RESET_FRAME_CTX_ALL, "RESET_FRAME_CTX_ALL"}),
+		  __entry->f.frame_context_idx,
+		  __entry->f.profile,
+		  __entry->f.bit_depth,
+		  __print_symbolic(__entry->f.interpolation_filter,
+		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP, "INTERP_FILTER_EIGHTTAP"},
+		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTH, "INTERP_FILTER_EIGHTTAP_SMOOTH"},
+		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARP, "INTERP_FILTER_EIGHTTAP_SHARP"},
+		  {V4L2_VP9_INTERP_FILTER_BILINEAR, "INTERP_FILTER_BILINEAR"},
+		  {V4L2_VP9_INTERP_FILTER_SWITCHABLE, "INTERP_FILTER_SWITCHABLE"}),
+		  __entry->f.tile_cols_log2,
+		  __entry->f.tile_rows_log2,
+		  __print_symbolic(__entry->f.reference_mode,
+		  {V4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCE, "REFERENCE_MODE_SINGLE_REFERENCE"},
+		  {V4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCE, "REFERENCE_MODE_COMPOUND_REFERENCE"},
+		  {V4L2_VP9_REFERENCE_MODE_SELECT, "REFERENCE_MODE_SELECT"}))
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(h),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
+	TP_fast_assign(__entry->h = *h;),
+	TP_printk("\ntx_mode %s\n"
+		  "tx8 {%s}\n"
+		  "tx16 {%s}\n"
+		  "tx32 {%s}\n"
+		  "skip %s\n"
+		  "inter_mode {%s}\n"
+		  "interp_filter {%s}\n"
+		  "is_inter %s\n"
+		  "comp_mode %s\n"
+		  "single_ref {%s}\n"
+		  "comp_ref %s\n"
+		  "y_mode {%s}\n"
+		  "uv_mode {%s}\n"
+		  "partition {%s}\n",
+		  __print_symbolic(__entry->h.tx_mode,
+		  {V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
+		  {V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
+		  {V4L2_VP9_TX_MODE_ALLOW_16X16, "TX_MODE_ALLOW_16X16"},
+		  {V4L2_VP9_TX_MODE_ALLOW_32X32, "TX_MODE_ALLOW_32X32"},
+		  {V4L2_VP9_TX_MODE_SELECT, "TX_MODE_SELECT"}),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.tx8,
+				   sizeof(__entry->h.tx8),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.tx16,
+				   sizeof(__entry->h.tx16),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.tx32,
+				   sizeof(__entry->h.tx32),
+				   false),
+		  __print_array(__entry->h.skip,
+				ARRAY_SIZE(__entry->h.skip),
+				sizeof(__entry->h.skip[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.inter_mode,
+				   sizeof(__entry->h.inter_mode),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.interp_filter,
+				   sizeof(__entry->h.interp_filter),
+				   false),
+		  __print_array(__entry->h.is_inter,
+				ARRAY_SIZE(__entry->h.is_inter),
+				sizeof(__entry->h.is_inter[0])),
+		  __print_array(__entry->h.comp_mode,
+				ARRAY_SIZE(__entry->h.comp_mode),
+				sizeof(__entry->h.comp_mode[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.single_ref,
+				   sizeof(__entry->h.single_ref),
+				   false),
+		  __print_array(__entry->h.comp_ref,
+				ARRAY_SIZE(__entry->h.comp_ref),
+				sizeof(__entry->h.comp_ref[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.y_mode,
+				   sizeof(__entry->h.y_mode),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.uv_mode,
+				   sizeof(__entry->h.uv_mode),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.partition,
+				   sizeof(__entry->h.partition),
+				   false)
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
+	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(h),
+	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
+	TP_fast_assign(__entry->h = *h;),
+	TP_printk("\n coef {%s}",
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->h.coef,
+				   sizeof(__entry->h.coef),
+				   false)
+	)
+);
+
+DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
+	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
+	TP_ARGS(p),
+	TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
+	TP_fast_assign(__entry->p = *p;),
+	TP_printk("\n joint %s\n"
+		  "sign %s\n"
+		  "classes {%s}\n"
+		  "class0_bit %s\n"
+		  "bits {%s}\n"
+		  "class0_fr {%s}\n"
+		  "fr {%s}\n"
+		  "class0_hp %s\n"
+		  "hp %s\n",
+		  __print_array(__entry->p.joint,
+				ARRAY_SIZE(__entry->p.joint),
+				sizeof(__entry->p.joint[0])),
+		  __print_array(__entry->p.sign,
+				ARRAY_SIZE(__entry->p.sign),
+				sizeof(__entry->p.sign[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.classes,
+				   sizeof(__entry->p.classes),
+				   false),
+		  __print_array(__entry->p.class0_bit,
+				ARRAY_SIZE(__entry->p.class0_bit),
+				sizeof(__entry->p.class0_bit[0])),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.bits,
+				   sizeof(__entry->p.bits),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.class0_fr,
+				   sizeof(__entry->p.class0_fr),
+				   false),
+		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
+				   __entry->p.fr,
+				   sizeof(__entry->p.fr),
+				   false),
+		  __print_array(__entry->p.class0_hp,
+				ARRAY_SIZE(__entry->p.class0_hp),
+				sizeof(__entry->p.class0_hp[0])),
+		  __print_array(__entry->p.hp,
+				ARRAY_SIZE(__entry->p.hp),
+				sizeof(__entry->p.hp[0]))
+	)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp9_frame_tmpl, v4l2_ctrl_vp9_frame,
+	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
+	TP_ARGS(f)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp9_compressed_hdr_tmpl, v4l2_ctrl_vp9_compressed_hdr,
+	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(h)
+);
+
+DEFINE_EVENT(v4l2_ctrl_vp9_compressed_coef_tmpl, v4l2_ctrl_vp9_compressed_coeff,
+	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(h)
+);
+
+
+DEFINE_EVENT(v4l2_vp9_mv_probs_tmpl, v4l2_vp9_mv_probs,
+	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
+	TP_ARGS(p)
+);
+
+#endif /* if !defined(_TRACE_V4L2_CONTROLS_H_) || defined(TRACE_HEADER_MULTI_READ) */
+
+#include <trace/define_trace.h>

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 2/9] media: Map each struct field to its own trace field
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 1/9] media: Move visl traces to v4l2-core Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 3/9] media: Add tgid and fd fields in v4l2_fh struct Detlev Casanova
                   ` (7 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

The trace events, moved from the visl driver, are simply using the
passed struct pointer to print the event in the trace.

This approach doesn't allow userspace to filter on fields, but also only
exposes the value of the pointer when using libtraceevent, which can't
be used to retrieve the control fields, forcing userspace to parse the
trace output.

To avoid that, list all fields from each passed struct in the trace.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 include/trace/events/v4l2_controls.h | 2171 ++++++++++++++++++++++++----------
 1 file changed, 1522 insertions(+), 649 deletions(-)

diff --git a/include/trace/events/v4l2_controls.h b/include/trace/events/v4l2_controls.h
index 9c74309b31ef..3a9bc75752bf 100644
--- a/include/trace/events/v4l2_controls.h
+++ b/include/trace/events/v4l2_controls.h
@@ -8,15 +8,34 @@
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM v4l2_controls
 
+/* V4L2 controls tracing events.
+ *
+ * These events are used to trace each V4L2 control when they are set by userspace.
+ * They can be identified by the name of the event. All control fields are copied in a TP_STRUCT
+ * field so that they can be filtered separately in userspace.
+ *
+ * Currently only the codec controls are supported.
+ */
+
 /* AV1 controls */
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_sequence, s)),
-	TP_fast_assign(__entry->s = *s;),
+	TP_STRUCT__entry(__field(__u32, flags)
+			 __field(__u8, seq_profile)
+			 __field(__u8, order_hint_bits)
+			 __field(__u8, bit_depth)
+			 __field(__u16, max_frame_width_minus_1)
+			 __field(__u16, max_frame_height_minus_1)),
+	TP_fast_assign(__entry->flags = s->flags;
+		       __entry->seq_profile = s->seq_profile;
+		       __entry->order_hint_bits = s->order_hint_bits;
+		       __entry->bit_depth = s->bit_depth;
+		       __entry->max_frame_width_minus_1 = s->max_frame_width_minus_1;
+		       __entry->max_frame_height_minus_1 = s->max_frame_height_minus_1;),
 	TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
 		  "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
-		  __print_flags(__entry->s.flags, "|",
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
 		  {V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
 		  {V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA, "ENABLE_FILTER_INTRA"},
@@ -37,32 +56,176 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
 		  {V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y, "SUBSAMPLING_Y"},
 		  {V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT, "FILM_GRAIN_PARAMS_PRESENT"},
 		  {V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q, "SEPARATE_UV_DELTA_Q"}),
-		  __entry->s.seq_profile,
-		  __entry->s.order_hint_bits,
-		  __entry->s.bit_depth,
-		  __entry->s.max_frame_width_minus_1,
-		  __entry->s.max_frame_height_minus_1
+		  __entry->seq_profile,
+		  __entry->order_hint_bits,
+		  __entry->bit_depth,
+		  __entry->max_frame_width_minus_1,
+		  __entry->max_frame_height_minus_1
 	)
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
 	TP_ARGS(t),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_tile_group_entry, t)),
-	TP_fast_assign(__entry->t = *t;),
+	TP_STRUCT__entry(__field(__u32, tile_offset)
+			 __field(__u32, tile_size)
+			 __field(__u32, tile_row)
+			 __field(__u32, tile_col)),
+	TP_fast_assign(__entry->tile_offset = t->tile_offset;
+		       __entry->tile_size = t->tile_size;
+		       __entry->tile_row = t->tile_row;
+		       __entry->tile_col = t->tile_col;),
 	TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
-		  __entry->t.tile_offset,
-		  __entry->t.tile_size,
-		  __entry->t.tile_row,
-		  __entry->t.tile_col
+		  __entry->tile_offset,
+		  __entry->tile_size,
+		  __entry->tile_row,
+		  __entry->tile_col
 	)
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
 	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
+	TP_STRUCT__entry(__field(u8, tile_info_flags)
+			 __field(u8, tile_info_context_update_tile_id)
+			 __field(u8, tile_info_tile_cols)
+			 __field(u8, tile_info_tile_rows)
+			 __array(u32, tile_info_mi_col_starts, V4L2_AV1_MAX_TILE_COLS + 1)
+			 __array(u32, tile_info_mi_row_starts, V4L2_AV1_MAX_TILE_ROWS + 1)
+			 __array(u32, tile_info_width_in_sbs_minus_1, V4L2_AV1_MAX_TILE_COLS)
+			 __array(u32, tile_info_height_in_sbs_minus_1, V4L2_AV1_MAX_TILE_ROWS)
+			 __field(u8, tile_info_tile_size_bytes)
+			 __field(u8, quantization_flags)
+			 __field(u8, quantization_base_q_idx)
+			 __field(s8, quantization_delta_q_y_dc)
+			 __field(s8, quantization_delta_q_u_dc)
+			 __field(s8, quantization_delta_q_u_ac)
+			 __field(s8, quantization_delta_q_v_dc)
+			 __field(s8, quantization_delta_q_v_ac)
+			 __field(u8, quantization_qm_y)
+			 __field(u8, quantization_qm_u)
+			 __field(u8, quantization_qm_v)
+			 __field(u8, quantization_delta_q_res)
+			 __field(u8, superres_denom)
+			 __field(u8, segmentation_flags)
+			 __field(u8, segmentation_last_active_seg_id)
+			 __array(u8, segmentation_feature_enabled, V4L2_AV1_MAX_SEGMENTS)
+			 __field(u8, loop_filter_flags)
+			 __array(u8, loop_filter_level, 4)
+			 __field(u8, loop_filter_sharpness)
+			 __array(s8, loop_filter_ref_deltas, V4L2_AV1_TOTAL_REFS_PER_FRAME)
+			 __array(s8, loop_filter_mode_deltas, 2)
+			 __field(u8, loop_filter_delta_lf_res)
+			 __field(u8, cdef_damping_minus_3)
+			 __field(u8, cdef_bits)
+			 __array(u8, cdef_y_pri_strength, V4L2_AV1_CDEF_MAX)
+			 __array(u8, cdef_y_sec_strength, V4L2_AV1_CDEF_MAX)
+			 __array(u8, cdef_uv_pri_strength, V4L2_AV1_CDEF_MAX)
+			 __array(u8, cdef_uv_sec_strength, V4L2_AV1_CDEF_MAX)
+			 __array(u8, skip_mode_frame, 2)
+			 __field(u8, primary_ref_frame)
+			 __field(u8, loop_restoration_flags)
+			 __field(u8, loop_restoration_lr_unit_shift)
+			 __field(u8, loop_restoration_lr_uv_shift)
+			 __array(int,
+				 loop_restoration_frame_restoration_type, V4L2_AV1_NUM_PLANES_MAX)
+			 __array(u32,
+				 loop_restoration_loop_restoration_size, V4L2_AV1_MAX_NUM_PLANES)
+			 __field(u32, flags)
+			 __field(u32, order_hint)
+			 __field(u32, upscaled_width)
+			 __field(u32, frame_width_minus_1)
+			 __field(u32, frame_height_minus_1)
+			 __field(u16, render_width_minus_1)
+			 __field(u16, render_height_minus_1)
+			 __field(u32, current_frame_id)
+			 __array(u32, buffer_removal_time, V4L2_AV1_MAX_OPERATING_POINTS)
+			 __array(u32, order_hints, V4L2_AV1_TOTAL_REFS_PER_FRAME)
+			 __array(u64, reference_frame_ts, V4L2_AV1_TOTAL_REFS_PER_FRAME)
+			 __array(s8, ref_frame_idx, V4L2_AV1_REFS_PER_FRAME)
+			 __field(u8, refresh_frame_flags)),
+	TP_fast_assign(__entry->tile_info_flags = f->tile_info.flags;
+		       __entry->tile_info_context_update_tile_id =
+				f->tile_info.context_update_tile_id;
+		       __entry->tile_info_tile_cols = f->tile_info.tile_cols;
+		       __entry->tile_info_tile_rows = f->tile_info.tile_rows;
+		       memcpy(__entry->tile_info_mi_col_starts, f->tile_info.mi_col_starts,
+			      sizeof(__entry->tile_info_mi_col_starts));
+		       memcpy(__entry->tile_info_mi_row_starts, f->tile_info.mi_row_starts,
+			      sizeof(__entry->tile_info_mi_row_starts));
+		       memcpy(__entry->tile_info_width_in_sbs_minus_1,
+			      f->tile_info.width_in_sbs_minus_1,
+			      sizeof(__entry->tile_info_width_in_sbs_minus_1));
+		       memcpy(__entry->tile_info_height_in_sbs_minus_1,
+			      f->tile_info.height_in_sbs_minus_1,
+			      sizeof(__entry->tile_info_height_in_sbs_minus_1));
+		       __entry->tile_info_tile_size_bytes = f->tile_info.tile_size_bytes;
+		       __entry->quantization_flags = f->quantization.flags;
+		       __entry->quantization_base_q_idx = f->quantization.base_q_idx;
+		       __entry->quantization_delta_q_y_dc = f->quantization.delta_q_y_dc;
+		       __entry->quantization_delta_q_u_dc = f->quantization.delta_q_u_dc;
+		       __entry->quantization_delta_q_u_ac = f->quantization.delta_q_u_ac;
+		       __entry->quantization_delta_q_v_dc = f->quantization.delta_q_v_dc;
+		       __entry->quantization_delta_q_v_ac = f->quantization.delta_q_v_ac;
+		       __entry->quantization_qm_y = f->quantization.qm_y;
+		       __entry->quantization_qm_u = f->quantization.qm_u;
+		       __entry->quantization_qm_v = f->quantization.qm_v;
+		       __entry->quantization_delta_q_res = f->quantization.delta_q_res;
+		       __entry->superres_denom = f->superres_denom;
+		       __entry->segmentation_flags = f->segmentation.flags;
+		       __entry->segmentation_last_active_seg_id =
+				f->segmentation.last_active_seg_id;
+		       memcpy(__entry->segmentation_feature_enabled,
+			      f->segmentation.feature_enabled,
+			      sizeof(__entry->segmentation_feature_enabled));
+		       __entry->loop_filter_flags = f->loop_filter.flags;
+		       memcpy(__entry->loop_filter_level, f->loop_filter.level,
+			      sizeof(__entry->loop_filter_level));
+		       __entry->loop_filter_sharpness = f->loop_filter.sharpness;
+		       memcpy(__entry->loop_filter_ref_deltas, f->loop_filter.ref_deltas,
+			      sizeof(__entry->loop_filter_ref_deltas));
+		       memcpy(__entry->loop_filter_mode_deltas, f->loop_filter.mode_deltas,
+			      sizeof(__entry->loop_filter_mode_deltas));
+		       __entry->loop_filter_delta_lf_res = f->loop_filter.delta_lf_res;
+		       __entry->cdef_damping_minus_3 = f->cdef.damping_minus_3;
+		       __entry->cdef_bits = f->cdef.bits;
+		       memcpy(__entry->cdef_y_pri_strength, f->cdef.y_pri_strength,
+			      sizeof(__entry->cdef_y_pri_strength));
+		       memcpy(__entry->cdef_y_sec_strength, f->cdef.y_sec_strength,
+			      sizeof(__entry->cdef_y_sec_strength));
+		       memcpy(__entry->cdef_uv_pri_strength, f->cdef.uv_pri_strength,
+			      sizeof(__entry->cdef_uv_pri_strength));
+		       memcpy(__entry->cdef_uv_sec_strength, f->cdef.uv_sec_strength,
+			      sizeof(__entry->cdef_uv_sec_strength));
+		       memcpy(__entry->skip_mode_frame, f->skip_mode_frame,
+			      sizeof(__entry->skip_mode_frame));
+		       __entry->primary_ref_frame = f->primary_ref_frame;
+		       __entry->loop_restoration_flags = f->loop_restoration.flags;
+		       __entry->loop_restoration_lr_unit_shift = f->loop_restoration.lr_unit_shift;
+		       __entry->loop_restoration_lr_uv_shift = f->loop_restoration.lr_uv_shift;
+		       memcpy(__entry->loop_restoration_frame_restoration_type,
+			      f->loop_restoration.frame_restoration_type,
+			      sizeof(__entry->loop_restoration_frame_restoration_type));
+		       memcpy(__entry->loop_restoration_loop_restoration_size,
+			      f->loop_restoration.loop_restoration_size,
+			      sizeof(__entry->loop_restoration_loop_restoration_size));
+		       __entry->flags = f->flags;
+		       __entry->order_hint = f->order_hint;
+		       __entry->upscaled_width = f->upscaled_width;
+		       __entry->frame_width_minus_1 = f->frame_width_minus_1;
+		       __entry->frame_height_minus_1 = f->frame_height_minus_1;
+		       __entry->render_width_minus_1 = f->render_width_minus_1;
+		       __entry->render_height_minus_1 = f->render_height_minus_1;
+		       __entry->current_frame_id = f->current_frame_id;
+		       memcpy(__entry->buffer_removal_time, f->buffer_removal_time,
+			      sizeof(__entry->buffer_removal_time));
+		       memcpy(__entry->order_hints, f->order_hints,
+			      sizeof(__entry->order_hints));
+		       memcpy(__entry->reference_frame_ts, f->reference_frame_ts,
+			      sizeof(__entry->reference_frame_ts));
+		       memcpy(__entry->ref_frame_idx, f->ref_frame_idx,
+			      sizeof(__entry->ref_frame_idx));
+		       __entry->refresh_frame_flags = f->refresh_frame_flags;),
 	TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
 		  "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
 		  "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
@@ -87,95 +250,95 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 		  "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
 		  "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
 		  "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
-		  __print_flags(__entry->f.tile_info.flags, "|",
+		  __print_flags(__entry->tile_info_flags, "|",
 		  {V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
-		  __entry->f.tile_info.context_update_tile_id,
-		  __entry->f.tile_info.tile_cols,
-		  __entry->f.tile_info.tile_rows,
-		  __print_array(__entry->f.tile_info.mi_col_starts,
-				ARRAY_SIZE(__entry->f.tile_info.mi_col_starts),
-				sizeof(__entry->f.tile_info.mi_col_starts[0])),
-		  __print_array(__entry->f.tile_info.mi_row_starts,
-				ARRAY_SIZE(__entry->f.tile_info.mi_row_starts),
-				sizeof(__entry->f.tile_info.mi_row_starts[0])),
-		  __print_array(__entry->f.tile_info.width_in_sbs_minus_1,
-				ARRAY_SIZE(__entry->f.tile_info.width_in_sbs_minus_1),
-				sizeof(__entry->f.tile_info.width_in_sbs_minus_1[0])),
-		  __print_array(__entry->f.tile_info.height_in_sbs_minus_1,
-				ARRAY_SIZE(__entry->f.tile_info.height_in_sbs_minus_1),
-				sizeof(__entry->f.tile_info.height_in_sbs_minus_1[0])),
-		  __entry->f.tile_info.tile_size_bytes,
-		  __print_flags(__entry->f.quantization.flags, "|",
+		  __entry->tile_info_context_update_tile_id,
+		  __entry->tile_info_tile_cols,
+		  __entry->tile_info_tile_rows,
+		  __print_array(__entry->tile_info_mi_col_starts,
+				ARRAY_SIZE(__entry->tile_info_mi_col_starts),
+				sizeof(__entry->tile_info_mi_col_starts[0])),
+		  __print_array(__entry->tile_info_mi_row_starts,
+				ARRAY_SIZE(__entry->tile_info_mi_row_starts),
+				sizeof(__entry->tile_info_mi_row_starts[0])),
+		  __print_array(__entry->tile_info_width_in_sbs_minus_1,
+				ARRAY_SIZE(__entry->tile_info_width_in_sbs_minus_1),
+				sizeof(__entry->tile_info_width_in_sbs_minus_1[0])),
+		  __print_array(__entry->tile_info_height_in_sbs_minus_1,
+				ARRAY_SIZE(__entry->tile_info_height_in_sbs_minus_1),
+				sizeof(__entry->tile_info_height_in_sbs_minus_1[0])),
+		  __entry->tile_info_tile_size_bytes,
+		  __print_flags(__entry->quantization_flags, "|",
 		  {V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA, "DIFF_UV_DELTA"},
 		  {V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX, "USING_QMATRIX"},
 		  {V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT, "DELTA_Q_PRESENT"}),
-		  __entry->f.quantization.base_q_idx,
-		  __entry->f.quantization.delta_q_y_dc,
-		  __entry->f.quantization.delta_q_u_dc,
-		  __entry->f.quantization.delta_q_u_ac,
-		  __entry->f.quantization.delta_q_v_dc,
-		  __entry->f.quantization.delta_q_v_ac,
-		  __entry->f.quantization.qm_y,
-		  __entry->f.quantization.qm_u,
-		  __entry->f.quantization.qm_v,
-		  __entry->f.quantization.delta_q_res,
-		  __entry->f.superres_denom,
-		  __print_flags(__entry->f.segmentation.flags, "|",
+		  __entry->quantization_base_q_idx,
+		  __entry->quantization_delta_q_y_dc,
+		  __entry->quantization_delta_q_u_dc,
+		  __entry->quantization_delta_q_u_ac,
+		  __entry->quantization_delta_q_v_dc,
+		  __entry->quantization_delta_q_v_ac,
+		  __entry->quantization_qm_y,
+		  __entry->quantization_qm_u,
+		  __entry->quantization_qm_v,
+		  __entry->quantization_delta_q_res,
+		  __entry->superres_denom,
+		  __print_flags(__entry->segmentation_flags, "|",
 		  {V4L2_AV1_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
 		  {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
 		  {V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
 		  {V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
 		  {V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP, "SEG_ID_PRE_SKIP"}),
-		  __entry->f.segmentation.last_active_seg_id,
-		  __print_array(__entry->f.segmentation.feature_enabled,
-				ARRAY_SIZE(__entry->f.segmentation.feature_enabled),
-				sizeof(__entry->f.segmentation.feature_enabled[0])),
-		  __print_flags(__entry->f.loop_filter.flags, "|",
+		  __entry->segmentation_last_active_seg_id,
+		  __print_array(__entry->segmentation_feature_enabled,
+				ARRAY_SIZE(__entry->segmentation_feature_enabled),
+				sizeof(__entry->segmentation_feature_enabled[0])),
+		  __print_flags(__entry->loop_filter_flags, "|",
 		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
 		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"},
 		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT, "DELTA_LF_PRESENT"},
 		  {V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI, "DELTA_LF_MULTI"}),
-		  __print_array(__entry->f.loop_filter.level,
-				ARRAY_SIZE(__entry->f.loop_filter.level),
-				sizeof(__entry->f.loop_filter.level[0])),
-		  __entry->f.loop_filter.sharpness,
-		  __print_array(__entry->f.loop_filter.ref_deltas,
-				ARRAY_SIZE(__entry->f.loop_filter.ref_deltas),
-				sizeof(__entry->f.loop_filter.ref_deltas[0])),
-		  __print_array(__entry->f.loop_filter.mode_deltas,
-				ARRAY_SIZE(__entry->f.loop_filter.mode_deltas),
-				sizeof(__entry->f.loop_filter.mode_deltas[0])),
-		  __entry->f.loop_filter.delta_lf_res,
-		  __entry->f.cdef.damping_minus_3,
-		  __entry->f.cdef.bits,
-		  __print_array(__entry->f.cdef.y_pri_strength,
-				ARRAY_SIZE(__entry->f.cdef.y_pri_strength),
-				sizeof(__entry->f.cdef.y_pri_strength[0])),
-		  __print_array(__entry->f.cdef.y_sec_strength,
-				ARRAY_SIZE(__entry->f.cdef.y_sec_strength),
-				sizeof(__entry->f.cdef.y_sec_strength[0])),
-		  __print_array(__entry->f.cdef.uv_pri_strength,
-				ARRAY_SIZE(__entry->f.cdef.uv_pri_strength),
-				sizeof(__entry->f.cdef.uv_pri_strength[0])),
-		  __print_array(__entry->f.cdef.uv_sec_strength,
-				ARRAY_SIZE(__entry->f.cdef.uv_sec_strength),
-				sizeof(__entry->f.cdef.uv_sec_strength[0])),
-		  __print_array(__entry->f.skip_mode_frame,
-				ARRAY_SIZE(__entry->f.skip_mode_frame),
-				sizeof(__entry->f.skip_mode_frame[0])),
-		  __entry->f.primary_ref_frame,
-		  __print_flags(__entry->f.loop_restoration.flags, "|",
+		  __print_array(__entry->loop_filter_level,
+				ARRAY_SIZE(__entry->loop_filter_level),
+				sizeof(__entry->loop_filter_level[0])),
+		  __entry->loop_filter_sharpness,
+		  __print_array(__entry->loop_filter_ref_deltas,
+				ARRAY_SIZE(__entry->loop_filter_ref_deltas),
+				sizeof(__entry->loop_filter_ref_deltas[0])),
+		  __print_array(__entry->loop_filter_mode_deltas,
+				ARRAY_SIZE(__entry->loop_filter_mode_deltas),
+				sizeof(__entry->loop_filter_mode_deltas[0])),
+		  __entry->loop_filter_delta_lf_res,
+		  __entry->cdef_damping_minus_3,
+		  __entry->cdef_bits,
+		  __print_array(__entry->cdef_y_pri_strength,
+				ARRAY_SIZE(__entry->cdef_y_pri_strength),
+				sizeof(__entry->cdef_y_pri_strength[0])),
+		  __print_array(__entry->cdef_y_sec_strength,
+				ARRAY_SIZE(__entry->cdef_y_sec_strength),
+				sizeof(__entry->cdef_y_sec_strength[0])),
+		  __print_array(__entry->cdef_uv_pri_strength,
+				ARRAY_SIZE(__entry->cdef_uv_pri_strength),
+				sizeof(__entry->cdef_uv_pri_strength[0])),
+		  __print_array(__entry->cdef_uv_sec_strength,
+				ARRAY_SIZE(__entry->cdef_uv_sec_strength),
+				sizeof(__entry->cdef_uv_sec_strength[0])),
+		  __print_array(__entry->skip_mode_frame,
+				ARRAY_SIZE(__entry->skip_mode_frame),
+				sizeof(__entry->skip_mode_frame[0])),
+		  __entry->primary_ref_frame,
+		  __print_flags(__entry->loop_restoration_flags, "|",
 		  {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR, "USES_LR"},
 		  {V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR, "USES_CHROMA_LR"}),
-		  __entry->f.loop_restoration.lr_unit_shift,
-		  __entry->f.loop_restoration.lr_uv_shift,
-		  __print_array(__entry->f.loop_restoration.frame_restoration_type,
-				ARRAY_SIZE(__entry->f.loop_restoration.frame_restoration_type),
-				sizeof(__entry->f.loop_restoration.frame_restoration_type[0])),
-		  __print_array(__entry->f.loop_restoration.loop_restoration_size,
-				ARRAY_SIZE(__entry->f.loop_restoration.loop_restoration_size),
-				sizeof(__entry->f.loop_restoration.loop_restoration_size[0])),
-		  __print_flags(__entry->f.flags, "|",
+		  __entry->loop_restoration_lr_unit_shift,
+		  __entry->loop_restoration_lr_uv_shift,
+		  __print_array(__entry->loop_restoration_frame_restoration_type,
+				ARRAY_SIZE(__entry->loop_restoration_frame_restoration_type),
+				sizeof(__entry->loop_restoration_frame_restoration_type[0])),
+		  __print_array(__entry->loop_restoration_loop_restoration_size,
+				ARRAY_SIZE(__entry->loop_restoration_loop_restoration_size),
+				sizeof(__entry->loop_restoration_loop_restoration_size[0])),
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_AV1_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
 		  {V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME, "SHOWABLE_FRAME"},
 		  {V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE, "ERROR_RESILIENT_MODE"},
@@ -197,26 +360,26 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 		  {V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE, "FRAME_SIZE_OVERRIDE"},
 		  {V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT, "BUFFER_REMOVAL_TIME_PRESENT"},
 		  {V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING, "FRAME_REFS_SHORT_SIGNALING"}),
-		  __entry->f.order_hint,
-		  __entry->f.upscaled_width,
-		  __entry->f.frame_width_minus_1,
-		  __entry->f.frame_height_minus_1,
-		  __entry->f.render_width_minus_1,
-		  __entry->f.render_height_minus_1,
-		  __entry->f.current_frame_id,
-		  __print_array(__entry->f.buffer_removal_time,
-				ARRAY_SIZE(__entry->f.buffer_removal_time),
-				sizeof(__entry->f.buffer_removal_time[0])),
-		  __print_array(__entry->f.order_hints,
-				ARRAY_SIZE(__entry->f.order_hints),
-				sizeof(__entry->f.order_hints[0])),
-		  __print_array(__entry->f.reference_frame_ts,
-				ARRAY_SIZE(__entry->f.reference_frame_ts),
-				sizeof(__entry->f.reference_frame_ts[0])),
-		  __print_array(__entry->f.ref_frame_idx,
-				ARRAY_SIZE(__entry->f.ref_frame_idx),
-				sizeof(__entry->f.ref_frame_idx[0])),
-		  __entry->f.refresh_frame_flags
+		  __entry->order_hint,
+		  __entry->upscaled_width,
+		  __entry->frame_width_minus_1,
+		  __entry->frame_height_minus_1,
+		  __entry->render_width_minus_1,
+		  __entry->render_height_minus_1,
+		  __entry->current_frame_id,
+		  __print_array(__entry->buffer_removal_time,
+				ARRAY_SIZE(__entry->buffer_removal_time),
+				sizeof(__entry->buffer_removal_time[0])),
+		  __print_array(__entry->order_hints,
+				ARRAY_SIZE(__entry->order_hints),
+				sizeof(__entry->order_hints[0])),
+		  __print_array(__entry->reference_frame_ts,
+				ARRAY_SIZE(__entry->reference_frame_ts),
+				sizeof(__entry->reference_frame_ts[0])),
+		  __print_array(__entry->ref_frame_idx,
+				ARRAY_SIZE(__entry->ref_frame_idx),
+				sizeof(__entry->ref_frame_idx[0])),
+		  __entry->refresh_frame_flags
 	)
 );
 
@@ -224,8 +387,65 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
 	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_av1_film_grain, f)),
-	TP_fast_assign(__entry->f = *f;),
+	TP_STRUCT__entry(__field(__u8, flags)
+			 __field(__u8, cr_mult)
+			 __field(__u16, grain_seed)
+			 __field(__u8, film_grain_params_ref_idx)
+			 __field(__u8, num_y_points)
+			 __array(__u8, point_y_value, V4L2_AV1_MAX_NUM_Y_POINTS)
+			 __array(__u8, point_y_scaling, V4L2_AV1_MAX_NUM_Y_POINTS)
+			 __field(__u8, num_cb_points)
+			 __array(__u8, point_cb_value, V4L2_AV1_MAX_NUM_CB_POINTS)
+			 __array(__u8, point_cb_scaling, V4L2_AV1_MAX_NUM_CB_POINTS)
+			 __field(__u8, num_cr_points)
+			 __array(__u8, point_cr_value, V4L2_AV1_MAX_NUM_CR_POINTS)
+			 __array(__u8, point_cr_scaling, V4L2_AV1_MAX_NUM_CR_POINTS)
+			 __field(__u8, grain_scaling_minus_8)
+			 __field(__u8, ar_coeff_lag)
+			 __array(__u8, ar_coeffs_y_plus_128, V4L2_AV1_AR_COEFFS_SIZE)
+			 __array(__u8, ar_coeffs_cb_plus_128, V4L2_AV1_AR_COEFFS_SIZE)
+			 __array(__u8, ar_coeffs_cr_plus_128, V4L2_AV1_AR_COEFFS_SIZE)
+			 __field(__u8, ar_coeff_shift_minus_6)
+			 __field(__u8, grain_scale_shift)
+			 __field(__u8, cb_mult)
+			 __field(__u8, cb_luma_mult)
+			 __field(__u8, cr_luma_mult)
+			 __field(__u16, cb_offset)
+			 __field(__u16, cr_offset)),
+	TP_fast_assign(__entry->flags = f->flags;
+		       __entry->cr_mult = f->cr_mult;
+		       __entry->grain_seed = f->grain_seed;
+		       __entry->film_grain_params_ref_idx = f->film_grain_params_ref_idx;
+		       __entry->num_y_points = f->num_y_points;
+		       memcpy(__entry->point_y_value, f->point_y_value,
+			      sizeof(__entry->point_y_value));
+		       memcpy(__entry->point_y_scaling, f->point_y_scaling,
+			      sizeof(__entry->point_y_scaling));
+		       __entry->num_cb_points = f->num_cb_points;
+		       memcpy(__entry->point_cb_value, f->point_cb_value,
+			      sizeof(__entry->point_cb_value));
+		       memcpy(__entry->point_cb_scaling, f->point_cb_scaling,
+			      sizeof(__entry->point_cb_scaling));
+		       __entry->num_cr_points = f->num_cr_points;
+		       memcpy(__entry->point_cr_value, f->point_cr_value,
+			      sizeof(__entry->point_cr_value));
+		       memcpy(__entry->point_cr_scaling, f->point_cr_scaling,
+			      sizeof(__entry->point_cr_scaling));
+		       __entry->grain_scaling_minus_8 = f->grain_scaling_minus_8;
+		       __entry->ar_coeff_lag = f->ar_coeff_lag;
+		       memcpy(__entry->ar_coeffs_y_plus_128, f->ar_coeffs_y_plus_128,
+			      sizeof(__entry->ar_coeffs_y_plus_128));
+		       memcpy(__entry->ar_coeffs_cb_plus_128, f->ar_coeffs_cb_plus_128,
+			      sizeof(__entry->ar_coeffs_cb_plus_128));
+		       memcpy(__entry->ar_coeffs_cr_plus_128, f->ar_coeffs_cr_plus_128,
+			      sizeof(__entry->ar_coeffs_cr_plus_128));
+		       __entry->ar_coeff_shift_minus_6 = f->ar_coeff_shift_minus_6;
+		       __entry->grain_scale_shift = f->grain_scale_shift;
+		       __entry->cb_mult = f->cb_mult;
+		       __entry->cb_luma_mult = f->cb_luma_mult;
+		       __entry->cr_luma_mult = f->cr_luma_mult;
+		       __entry->cb_offset = f->cb_offset;
+		       __entry->cr_offset = f->cr_offset;),
 	TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
 		  "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
 		  "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
@@ -235,54 +455,54 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
 		  "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
 		  "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
 		  "cb_offset: %u\ncr_offset: %u\n",
-		  __print_flags(__entry->f.flags, "|",
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
 		  {V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
 		  {V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA, "CHROMA_SCALING_FROM_LUMA"},
 		  {V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP, "OVERLAP"},
 		  {V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE, "CLIP_TO_RESTRICTED_RANGE"}),
-		  __entry->f.cr_mult,
-		  __entry->f.grain_seed,
-		  __entry->f.film_grain_params_ref_idx,
-		  __entry->f.num_y_points,
-		  __print_array(__entry->f.point_y_value,
-				ARRAY_SIZE(__entry->f.point_y_value),
-				sizeof(__entry->f.point_y_value[0])),
-		  __print_array(__entry->f.point_y_scaling,
-				ARRAY_SIZE(__entry->f.point_y_scaling),
-				sizeof(__entry->f.point_y_scaling[0])),
-		  __entry->f.num_cb_points,
-		  __print_array(__entry->f.point_cb_value,
-				ARRAY_SIZE(__entry->f.point_cb_value),
-				sizeof(__entry->f.point_cb_value[0])),
-		  __print_array(__entry->f.point_cb_scaling,
-				ARRAY_SIZE(__entry->f.point_cb_scaling),
-				sizeof(__entry->f.point_cb_scaling[0])),
-		  __entry->f.num_cr_points,
-		  __print_array(__entry->f.point_cr_value,
-				ARRAY_SIZE(__entry->f.point_cr_value),
-				sizeof(__entry->f.point_cr_value[0])),
-		  __print_array(__entry->f.point_cr_scaling,
-				ARRAY_SIZE(__entry->f.point_cr_scaling),
-				sizeof(__entry->f.point_cr_scaling[0])),
-		  __entry->f.grain_scaling_minus_8,
-		  __entry->f.ar_coeff_lag,
-		  __print_array(__entry->f.ar_coeffs_y_plus_128,
-				ARRAY_SIZE(__entry->f.ar_coeffs_y_plus_128),
-				sizeof(__entry->f.ar_coeffs_y_plus_128[0])),
-		  __print_array(__entry->f.ar_coeffs_cb_plus_128,
-				ARRAY_SIZE(__entry->f.ar_coeffs_cb_plus_128),
-				sizeof(__entry->f.ar_coeffs_cb_plus_128[0])),
-		  __print_array(__entry->f.ar_coeffs_cr_plus_128,
-				ARRAY_SIZE(__entry->f.ar_coeffs_cr_plus_128),
-				sizeof(__entry->f.ar_coeffs_cr_plus_128[0])),
-		  __entry->f.ar_coeff_shift_minus_6,
-		  __entry->f.grain_scale_shift,
-		  __entry->f.cb_mult,
-		  __entry->f.cb_luma_mult,
-		  __entry->f.cr_luma_mult,
-		  __entry->f.cb_offset,
-		  __entry->f.cr_offset
+		  __entry->cr_mult,
+		  __entry->grain_seed,
+		  __entry->film_grain_params_ref_idx,
+		  __entry->num_y_points,
+		  __print_array(__entry->point_y_value,
+				ARRAY_SIZE(__entry->point_y_value),
+				sizeof(__entry->point_y_value[0])),
+		  __print_array(__entry->point_y_scaling,
+				ARRAY_SIZE(__entry->point_y_scaling),
+				sizeof(__entry->point_y_scaling[0])),
+		  __entry->num_cb_points,
+		  __print_array(__entry->point_cb_value,
+				ARRAY_SIZE(__entry->point_cb_value),
+				sizeof(__entry->point_cb_value[0])),
+		  __print_array(__entry->point_cb_scaling,
+				ARRAY_SIZE(__entry->point_cb_scaling),
+				sizeof(__entry->point_cb_scaling[0])),
+		  __entry->num_cr_points,
+		  __print_array(__entry->point_cr_value,
+				ARRAY_SIZE(__entry->point_cr_value),
+				sizeof(__entry->point_cr_value[0])),
+		  __print_array(__entry->point_cr_scaling,
+				ARRAY_SIZE(__entry->point_cr_scaling),
+				sizeof(__entry->point_cr_scaling[0])),
+		  __entry->grain_scaling_minus_8,
+		  __entry->ar_coeff_lag,
+		  __print_array(__entry->ar_coeffs_y_plus_128,
+				ARRAY_SIZE(__entry->ar_coeffs_y_plus_128),
+				sizeof(__entry->ar_coeffs_y_plus_128[0])),
+		  __print_array(__entry->ar_coeffs_cb_plus_128,
+				ARRAY_SIZE(__entry->ar_coeffs_cb_plus_128),
+				sizeof(__entry->ar_coeffs_cb_plus_128[0])),
+		  __print_array(__entry->ar_coeffs_cr_plus_128,
+				ARRAY_SIZE(__entry->ar_coeffs_cr_plus_128),
+				sizeof(__entry->ar_coeffs_cr_plus_128[0])),
+		  __entry->ar_coeff_shift_minus_6,
+		  __entry->grain_scale_shift,
+		  __entry->cb_mult,
+		  __entry->cb_luma_mult,
+		  __entry->cr_luma_mult,
+		  __entry->cb_offset,
+		  __entry->cr_offset
 	)
 )
 
@@ -333,7 +553,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
 		       __entry->ycbcr_enc = p->ycbcr_enc;
 		       __entry->quantization = p->quantization;
 		       ),
-	TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u xfer_func %u ycbcr_enc %u quantization %u",
+	TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u "
+		  "xfer_func %u ycbcr_enc %u quantization %u",
 		  __entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
 		  __print_flags(__entry->flags, "|",
 		  {V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
@@ -362,8 +583,45 @@ DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_sps, s)),
-	TP_fast_assign(__entry->s = *s),
+	TP_STRUCT__entry(__field(u8, profile_idc)
+			 __field(u8, constraint_set_flags)
+			 __field(u8, level_idc)
+			 __field(u8, seq_parameter_set_id)
+			 __field(u8, chroma_format_idc)
+			 __field(u8, bit_depth_luma_minus8)
+			 __field(u8, bit_depth_chroma_minus8)
+			 __field(u8, log2_max_frame_num_minus4)
+			 __field(u8, pic_order_cnt_type)
+			 __field(u8, log2_max_pic_order_cnt_lsb_minus4)
+			 __field(u8, max_num_ref_frames)
+			 __field(u8, num_ref_frames_in_pic_order_cnt_cycle)
+			 __array(__s32, offset_for_ref_frame, 255)
+			 __field(__s32, offset_for_non_ref_pic)
+			 __field(__s32, offset_for_top_to_bottom_field)
+			 __field(u16, pic_width_in_mbs_minus1)
+			 __field(u16, pic_height_in_map_units_minus1)
+			 __field(u32, flags)),
+	TP_fast_assign(__entry->profile_idc = s->profile_idc;
+		       __entry->constraint_set_flags = s->constraint_set_flags;
+		       __entry->level_idc = s->level_idc;
+		       __entry->seq_parameter_set_id = s->seq_parameter_set_id;
+		       __entry->chroma_format_idc = s->chroma_format_idc;
+		       __entry->bit_depth_luma_minus8 = s->bit_depth_luma_minus8;
+		       __entry->bit_depth_chroma_minus8 = s->bit_depth_chroma_minus8;
+		       __entry->log2_max_frame_num_minus4 = s->log2_max_frame_num_minus4;
+		       __entry->pic_order_cnt_type = s->pic_order_cnt_type;
+		       __entry->log2_max_pic_order_cnt_lsb_minus4 =
+				s->log2_max_pic_order_cnt_lsb_minus4;
+		       __entry->max_num_ref_frames = s->max_num_ref_frames;
+		       __entry->num_ref_frames_in_pic_order_cnt_cycle =
+				s->num_ref_frames_in_pic_order_cnt_cycle;
+		       memcpy(__entry->offset_for_ref_frame, s->offset_for_ref_frame,
+			      sizeof(__entry->offset_for_ref_frame));
+		       __entry->offset_for_non_ref_pic = s->offset_for_non_ref_pic;
+		       __entry->offset_for_top_to_bottom_field = s->offset_for_top_to_bottom_field;
+		       __entry->pic_width_in_mbs_minus1 = s->pic_width_in_mbs_minus1;
+		       __entry->pic_height_in_map_units_minus1 = s->pic_height_in_map_units_minus1;
+		       __entry->flags = s->flags),
 	TP_printk("\nprofile_idc %u\n"
 		  "constraint_set_flags %s\n"
 		  "level_idc %u\n"
@@ -382,36 +640,38 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 		  "pic_width_in_mbs_minus1 %u\n"
 		  "pic_height_in_map_units_minus1 %u\n"
 		  "flags %s",
-		  __entry->s.profile_idc,
-		  __print_flags(__entry->s.constraint_set_flags, "|",
+		  __entry->profile_idc,
+		  __print_flags(__entry->constraint_set_flags, "|",
 		  {V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
 		  {V4L2_H264_SPS_CONSTRAINT_SET1_FLAG, "CONSTRAINT_SET1_FLAG"},
 		  {V4L2_H264_SPS_CONSTRAINT_SET2_FLAG, "CONSTRAINT_SET2_FLAG"},
 		  {V4L2_H264_SPS_CONSTRAINT_SET3_FLAG, "CONSTRAINT_SET3_FLAG"},
 		  {V4L2_H264_SPS_CONSTRAINT_SET4_FLAG, "CONSTRAINT_SET4_FLAG"},
 		  {V4L2_H264_SPS_CONSTRAINT_SET5_FLAG, "CONSTRAINT_SET5_FLAG"}),
-		  __entry->s.level_idc,
-		  __entry->s.seq_parameter_set_id,
-		  __entry->s.chroma_format_idc,
-		  __entry->s.bit_depth_luma_minus8,
-		  __entry->s.bit_depth_chroma_minus8,
-		  __entry->s.log2_max_frame_num_minus4,
-		  __entry->s.pic_order_cnt_type,
-		  __entry->s.log2_max_pic_order_cnt_lsb_minus4,
-		  __entry->s.max_num_ref_frames,
-		  __entry->s.num_ref_frames_in_pic_order_cnt_cycle,
-		  __print_array(__entry->s.offset_for_ref_frame,
-				ARRAY_SIZE(__entry->s.offset_for_ref_frame),
-				sizeof(__entry->s.offset_for_ref_frame[0])),
-		  __entry->s.offset_for_non_ref_pic,
-		  __entry->s.offset_for_top_to_bottom_field,
-		  __entry->s.pic_width_in_mbs_minus1,
-		  __entry->s.pic_height_in_map_units_minus1,
-		  __print_flags(__entry->s.flags, "|",
+		  __entry->level_idc,
+		  __entry->seq_parameter_set_id,
+		  __entry->chroma_format_idc,
+		  __entry->bit_depth_luma_minus8,
+		  __entry->bit_depth_chroma_minus8,
+		  __entry->log2_max_frame_num_minus4,
+		  __entry->pic_order_cnt_type,
+		  __entry->log2_max_pic_order_cnt_lsb_minus4,
+		  __entry->max_num_ref_frames,
+		  __entry->num_ref_frames_in_pic_order_cnt_cycle,
+		  __print_array(__entry->offset_for_ref_frame,
+				ARRAY_SIZE(__entry->offset_for_ref_frame),
+				sizeof(__entry->offset_for_ref_frame[0])),
+		  __entry->offset_for_non_ref_pic,
+		  __entry->offset_for_top_to_bottom_field,
+		  __entry->pic_width_in_mbs_minus1,
+		  __entry->pic_height_in_map_units_minus1,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
-		  {V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS, "QPPRIME_Y_ZERO_TRANSFORM_BYPASS"},
+		  {V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS,
+		   "QPPRIME_Y_ZERO_TRANSFORM_BYPASS"},
 		  {V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO, "DELTA_PIC_ORDER_ALWAYS_ZERO"},
-		  {V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED, "GAPS_IN_FRAME_NUM_VALUE_ALLOWED"},
+		  {V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED,
+		   "GAPS_IN_FRAME_NUM_VALUE_ALLOWED"},
 		  {V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY, "FRAME_MBS_ONLY"},
 		  {V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD, "MB_ADAPTIVE_FRAME_FIELD"},
 		  {V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE, "DIRECT_8X8_INFERENCE"}
@@ -421,8 +681,30 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
 	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pps, p)),
-	TP_fast_assign(__entry->p = *p),
+	TP_STRUCT__entry(__field(u8, pic_parameter_set_id)
+			 __field(u8, seq_parameter_set_id)
+			 __field(u8, num_slice_groups_minus1)
+			 __field(u8, num_ref_idx_l0_default_active_minus1)
+			 __field(u8, num_ref_idx_l1_default_active_minus1)
+			 __field(u8, weighted_bipred_idc)
+			 __field(__s8, pic_init_qp_minus26)
+			 __field(__s8, pic_init_qs_minus26)
+			 __field(__s8, chroma_qp_index_offset)
+			 __field(__s8, second_chroma_qp_index_offset)
+			 __field(u16, flags)),
+	TP_fast_assign(__entry->pic_parameter_set_id = p->pic_parameter_set_id;
+		       __entry->seq_parameter_set_id = p->seq_parameter_set_id;
+		       __entry->num_slice_groups_minus1 = p->num_slice_groups_minus1;
+		       __entry->num_ref_idx_l0_default_active_minus1 =
+				p->num_ref_idx_l0_default_active_minus1;
+		       __entry->num_ref_idx_l1_default_active_minus1 =
+				p->num_ref_idx_l1_default_active_minus1;
+		       __entry->weighted_bipred_idc = p->weighted_bipred_idc;
+		       __entry->pic_init_qp_minus26 = p->pic_init_qp_minus26;
+		       __entry->pic_init_qs_minus26 = p->pic_init_qs_minus26;
+		       __entry->chroma_qp_index_offset = p->chroma_qp_index_offset;
+		       __entry->second_chroma_qp_index_offset = p->second_chroma_qp_index_offset;
+		       __entry->flags = p->flags),
 	TP_printk("\npic_parameter_set_id %u\n"
 		  "seq_parameter_set_id %u\n"
 		  "num_slice_groups_minus1 %u\n"
@@ -434,21 +716,23 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 		  "chroma_qp_index_offset %d\n"
 		  "second_chroma_qp_index_offset %d\n"
 		  "flags %s",
-		  __entry->p.pic_parameter_set_id,
-		  __entry->p.seq_parameter_set_id,
-		  __entry->p.num_slice_groups_minus1,
-		  __entry->p.num_ref_idx_l0_default_active_minus1,
-		  __entry->p.num_ref_idx_l1_default_active_minus1,
-		  __entry->p.weighted_bipred_idc,
-		  __entry->p.pic_init_qp_minus26,
-		  __entry->p.pic_init_qs_minus26,
-		  __entry->p.chroma_qp_index_offset,
-		  __entry->p.second_chroma_qp_index_offset,
-		  __print_flags(__entry->p.flags, "|",
+		  __entry->pic_parameter_set_id,
+		  __entry->seq_parameter_set_id,
+		  __entry->num_slice_groups_minus1,
+		  __entry->num_ref_idx_l0_default_active_minus1,
+		  __entry->num_ref_idx_l1_default_active_minus1,
+		  __entry->weighted_bipred_idc,
+		  __entry->pic_init_qp_minus26,
+		  __entry->pic_init_qs_minus26,
+		  __entry->chroma_qp_index_offset,
+		  __entry->second_chroma_qp_index_offset,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE, "ENTROPY_CODING_MODE"},
-		  {V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT, "BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT"},
+		  {V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT,
+		   "BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT"},
 		  {V4L2_H264_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
-		  {V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
+		  {V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT,
+		   "DEBLOCKING_FILTER_CONTROL_PRESENT"},
 		  {V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
 		  {V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT, "REDUNDANT_PIC_CNT_PRESENT"},
 		  {V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE, "TRANSFORM_8X8_MODE"},
@@ -459,16 +743,20 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_scaling_matrix, s)),
-	TP_fast_assign(__entry->s = *s),
+	TP_STRUCT__entry(__array(u8, scaling_list_4x4, 6 * 16)
+			 __array(u8, scaling_list_8x8, 6 * 64)),
+	TP_fast_assign(memcpy(__entry->scaling_list_4x4, s->scaling_list_4x4,
+			      sizeof(__entry->scaling_list_4x4));
+		       memcpy(__entry->scaling_list_8x8, s->scaling_list_8x8,
+			      sizeof(__entry->scaling_list_8x8))),
 	TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_4x4,
-				   sizeof(__entry->s.scaling_list_4x4),
+				   __entry->scaling_list_4x4,
+				   sizeof(__entry->scaling_list_4x4),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_8x8,
-				   sizeof(__entry->s.scaling_list_8x8),
+				   __entry->scaling_list_8x8,
+				   sizeof(__entry->scaling_list_8x8),
 				   false)
 	)
 );
@@ -476,8 +764,42 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
 	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_pred_weights, p)),
-	TP_fast_assign(__entry->p = *p),
+	TP_STRUCT__entry(__field(u16, luma_log2_weight_denom)
+			 __field(u16, chroma_log2_weight_denom)
+			 __array(__s16, weight_factors_0_luma_weight, 32)
+			 __array(__s16, weight_factors_0_luma_offset, 32)
+			 __array(__s16, weight_factors_0_chroma_weight, 32 * 2)
+			 __array(__s16, weight_factors_0_chroma_offset, 32 * 2)
+			 __array(__s16, weight_factors_1_luma_weight, 32)
+			 __array(__s16, weight_factors_1_luma_offset, 32)
+			 __array(__s16, weight_factors_1_chroma_weight, 32 * 2)
+			 __array(__s16, weight_factors_1_chroma_offset, 32 * 2)),
+	TP_fast_assign(__entry->luma_log2_weight_denom = p->luma_log2_weight_denom;
+		       __entry->chroma_log2_weight_denom = p->chroma_log2_weight_denom;
+		       memcpy(__entry->weight_factors_0_luma_weight,
+			      p->weight_factors[0].luma_weight,
+			      sizeof(__entry->weight_factors_0_luma_weight));
+		       memcpy(__entry->weight_factors_0_luma_offset,
+			      p->weight_factors[0].luma_offset,
+			      sizeof(__entry->weight_factors_0_luma_offset));
+		       memcpy(__entry->weight_factors_0_chroma_weight,
+			      p->weight_factors[0].chroma_weight,
+			      sizeof(__entry->weight_factors_0_chroma_weight));
+		       memcpy(__entry->weight_factors_0_chroma_offset,
+			      p->weight_factors[0].chroma_offset,
+			      sizeof(__entry->weight_factors_0_chroma_offset));
+		       memcpy(__entry->weight_factors_1_luma_weight,
+			      p->weight_factors[1].luma_weight,
+			      sizeof(__entry->weight_factors_1_luma_weight));
+		       memcpy(__entry->weight_factors_1_luma_offset,
+			      p->weight_factors[1].luma_offset,
+			      sizeof(__entry->weight_factors_1_luma_offset));
+		       memcpy(__entry->weight_factors_1_chroma_weight,
+			      p->weight_factors[1].chroma_weight,
+			      sizeof(__entry->weight_factors_1_chroma_weight));
+		       memcpy(__entry->weight_factors_1_chroma_offset,
+			      p->weight_factors[1].chroma_offset,
+			      sizeof(__entry->weight_factors_1_chroma_offset))),
 	TP_printk("\nluma_log2_weight_denom %u\n"
 		  "chroma_log2_weight_denom %u\n"
 		  "weight_factor[0].luma_weight %s\n"
@@ -488,35 +810,35 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 		  "weight_factor[1].luma_offset %s\n"
 		  "weight_factor[1].chroma_weight {%s}\n"
 		  "weight_factor[1].chroma_offset {%s}\n",
-		  __entry->p.luma_log2_weight_denom,
-		  __entry->p.chroma_log2_weight_denom,
-		  __print_array(__entry->p.weight_factors[0].luma_weight,
-				ARRAY_SIZE(__entry->p.weight_factors[0].luma_weight),
-				sizeof(__entry->p.weight_factors[0].luma_weight[0])),
-		  __print_array(__entry->p.weight_factors[0].luma_offset,
-				ARRAY_SIZE(__entry->p.weight_factors[0].luma_offset),
-				sizeof(__entry->p.weight_factors[0].luma_offset[0])),
+		  __entry->luma_log2_weight_denom,
+		  __entry->chroma_log2_weight_denom,
+		  __print_array(__entry->weight_factors_0_luma_weight,
+				ARRAY_SIZE(__entry->weight_factors_0_luma_weight),
+				sizeof(__entry->weight_factors_0_luma_weight[0])),
+		  __print_array(__entry->weight_factors_0_luma_offset,
+				ARRAY_SIZE(__entry->weight_factors_0_luma_offset),
+				sizeof(__entry->weight_factors_0_luma_offset[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[0].chroma_weight,
-				   sizeof(__entry->p.weight_factors[0].chroma_weight),
+				   __entry->weight_factors_0_chroma_weight,
+				   sizeof(__entry->weight_factors_0_chroma_weight),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[0].chroma_offset,
-				   sizeof(__entry->p.weight_factors[0].chroma_offset),
+				   __entry->weight_factors_0_chroma_offset,
+				   sizeof(__entry->weight_factors_0_chroma_offset),
 				   false),
-		  __print_array(__entry->p.weight_factors[1].luma_weight,
-				ARRAY_SIZE(__entry->p.weight_factors[1].luma_weight),
-				sizeof(__entry->p.weight_factors[1].luma_weight[0])),
-		  __print_array(__entry->p.weight_factors[1].luma_offset,
-				ARRAY_SIZE(__entry->p.weight_factors[1].luma_offset),
-				sizeof(__entry->p.weight_factors[1].luma_offset[0])),
+		  __print_array(__entry->weight_factors_1_luma_weight,
+				ARRAY_SIZE(__entry->weight_factors_1_luma_weight),
+				sizeof(__entry->weight_factors_1_luma_weight[0])),
+		  __print_array(__entry->weight_factors_1_luma_offset,
+				ARRAY_SIZE(__entry->weight_factors_1_luma_offset),
+				sizeof(__entry->weight_factors_1_luma_offset[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[1].chroma_weight,
-				   sizeof(__entry->p.weight_factors[1].chroma_weight),
+				   __entry->weight_factors_1_chroma_weight,
+				   sizeof(__entry->weight_factors_1_chroma_weight),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.weight_factors[1].chroma_offset,
-				   sizeof(__entry->p.weight_factors[1].chroma_offset),
+				   __entry->weight_factors_1_chroma_offset,
+				   sizeof(__entry->weight_factors_1_chroma_offset),
 				   false)
 	)
 );
@@ -524,8 +846,34 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_slice_params, s)),
-	TP_fast_assign(__entry->s = *s),
+	TP_STRUCT__entry(__field(u32, header_bit_size)
+			 __field(u32, first_mb_in_slice)
+			 __field(u8, slice_type)
+			 __field(u8, colour_plane_id)
+			 __field(u8, redundant_pic_cnt)
+			 __field(u8, cabac_init_idc)
+			 __field(__s8, slice_qp_delta)
+			 __field(__s8, slice_qs_delta)
+			 __field(u8, disable_deblocking_filter_idc)
+			 __field(__s8, slice_alpha_c0_offset_div2)
+			 __field(__s8, slice_beta_offset_div2)
+			 __field(u8, num_ref_idx_l0_active_minus1)
+			 __field(u8, num_ref_idx_l1_active_minus1)
+			 __field(u32, flags)),
+	TP_fast_assign(__entry->header_bit_size = s->header_bit_size;
+		       __entry->first_mb_in_slice = s->first_mb_in_slice;
+		       __entry->slice_type = s->slice_type;
+		       __entry->colour_plane_id = s->colour_plane_id;
+		       __entry->redundant_pic_cnt = s->redundant_pic_cnt;
+		       __entry->cabac_init_idc = s->cabac_init_idc;
+		       __entry->slice_qp_delta = s->slice_qp_delta;
+		       __entry->slice_qs_delta = s->slice_qs_delta;
+		       __entry->disable_deblocking_filter_idc = s->disable_deblocking_filter_idc;
+		       __entry->slice_alpha_c0_offset_div2 = s->slice_alpha_c0_offset_div2;
+		       __entry->slice_beta_offset_div2 = s->slice_beta_offset_div2;
+		       __entry->num_ref_idx_l0_active_minus1 = s->num_ref_idx_l0_active_minus1;
+		       __entry->num_ref_idx_l1_active_minus1 = s->num_ref_idx_l1_active_minus1;
+		       __entry->flags = s->flags),
 	TP_printk("\nheader_bit_size %u\n"
 		  "first_mb_in_slice %u\n"
 		  "slice_type %s\n"
@@ -540,25 +888,25 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 		  "num_ref_idx_l0_active_minus1 %u\n"
 		  "num_ref_idx_l1_active_minus1 %u\n"
 		  "flags %s",
-		  __entry->s.header_bit_size,
-		  __entry->s.first_mb_in_slice,
-		  __print_symbolic(__entry->s.slice_type,
+		  __entry->header_bit_size,
+		  __entry->first_mb_in_slice,
+		  __print_symbolic(__entry->slice_type,
 		  {V4L2_H264_SLICE_TYPE_P, "P"},
 		  {V4L2_H264_SLICE_TYPE_B, "B"},
 		  {V4L2_H264_SLICE_TYPE_I, "I"},
 		  {V4L2_H264_SLICE_TYPE_SP, "SP"},
 		  {V4L2_H264_SLICE_TYPE_SI, "SI"}),
-		  __entry->s.colour_plane_id,
-		  __entry->s.redundant_pic_cnt,
-		  __entry->s.cabac_init_idc,
-		  __entry->s.slice_qp_delta,
-		  __entry->s.slice_qs_delta,
-		  __entry->s.disable_deblocking_filter_idc,
-		  __entry->s.slice_alpha_c0_offset_div2,
-		  __entry->s.slice_beta_offset_div2,
-		  __entry->s.num_ref_idx_l0_active_minus1,
-		  __entry->s.num_ref_idx_l1_active_minus1,
-		  __print_flags(__entry->s.flags, "|",
+		  __entry->colour_plane_id,
+		  __entry->redundant_pic_cnt,
+		  __entry->cabac_init_idc,
+		  __entry->slice_qp_delta,
+		  __entry->slice_qs_delta,
+		  __entry->disable_deblocking_filter_idc,
+		  __entry->slice_alpha_c0_offset_div2,
+		  __entry->slice_beta_offset_div2,
+		  __entry->num_ref_idx_l0_active_minus1,
+		  __entry->num_ref_idx_l1_active_minus1,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED, "DIRECT_SPATIAL_MV_PRED"},
 		  {V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH, "SP_FOR_SWITCH"})
 	)
@@ -567,24 +915,51 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
 	TP_PROTO(const struct v4l2_h264_reference *r, int i),
 	TP_ARGS(r, i),
-	TP_STRUCT__entry(__field_struct(struct v4l2_h264_reference, r)
+	TP_STRUCT__entry(__field(u8, fields)
+			 __field(u8, index)
 			 __field(int, i)),
-	TP_fast_assign(__entry->r = *r; __entry->i = i;),
+	TP_fast_assign(__entry->fields = r->fields;
+		       __entry->index = r->index;
+		       __entry->i = i;),
 	TP_printk("[%d]: fields %s index %u",
 		  __entry->i,
-		  __print_flags(__entry->r.fields, "|",
+		  __print_flags(__entry->fields, "|",
 		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
 		  {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
 		  {V4L2_H264_FRAME_REF, "FRAME_REF"}),
-		  __entry->r.index
+		  __entry->index
 	)
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
 	TP_ARGS(d),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_h264_decode_params, d)),
-	TP_fast_assign(__entry->d = *d),
+	TP_STRUCT__entry(__field(u16, nal_ref_idc)
+			 __field(u16, frame_num)
+			 __field(__s32, top_field_order_cnt)
+			 __field(__s32, bottom_field_order_cnt)
+			 __field(u16, idr_pic_id)
+			 __field(u16, pic_order_cnt_lsb)
+			 __field(__s32, delta_pic_order_cnt_bottom)
+			 __field(__s32, delta_pic_order_cnt0)
+			 __field(__s32, delta_pic_order_cnt1)
+			 __field(u32, dec_ref_pic_marking_bit_size)
+			 __field(u32, pic_order_cnt_bit_size)
+			 __field(u32, slice_group_change_cycle)
+			 __field(u32, flags)),
+	TP_fast_assign(__entry->nal_ref_idc = d->nal_ref_idc;
+		       __entry->frame_num = d->frame_num;
+		       __entry->top_field_order_cnt = d->top_field_order_cnt;
+		       __entry->bottom_field_order_cnt = d->bottom_field_order_cnt;
+		       __entry->idr_pic_id = d->idr_pic_id;
+		       __entry->pic_order_cnt_lsb = d->pic_order_cnt_lsb;
+		       __entry->delta_pic_order_cnt_bottom = d->delta_pic_order_cnt_bottom;
+		       __entry->delta_pic_order_cnt0 = d->delta_pic_order_cnt0;
+		       __entry->delta_pic_order_cnt1 = d->delta_pic_order_cnt1;
+		       __entry->dec_ref_pic_marking_bit_size = d->dec_ref_pic_marking_bit_size;
+		       __entry->pic_order_cnt_bit_size = d->pic_order_cnt_bit_size;
+		       __entry->slice_group_change_cycle = d->slice_group_change_cycle;
+		       __entry->flags = d->flags),
 	TP_printk("\nnal_ref_idc %u\n"
 		  "frame_num %u\n"
 		  "top_field_order_cnt %d\n"
@@ -598,19 +973,19 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 		  "pic_order_cnt_bit_size %u\n"
 		  "slice_group_change_cycle %u\n"
 		  "flags %s\n",
-		  __entry->d.nal_ref_idc,
-		  __entry->d.frame_num,
-		  __entry->d.top_field_order_cnt,
-		  __entry->d.bottom_field_order_cnt,
-		  __entry->d.idr_pic_id,
-		  __entry->d.pic_order_cnt_lsb,
-		  __entry->d.delta_pic_order_cnt_bottom,
-		  __entry->d.delta_pic_order_cnt0,
-		  __entry->d.delta_pic_order_cnt1,
-		  __entry->d.dec_ref_pic_marking_bit_size,
-		  __entry->d.pic_order_cnt_bit_size,
-		  __entry->d.slice_group_change_cycle,
-		  __print_flags(__entry->d.flags, "|",
+		  __entry->nal_ref_idc,
+		  __entry->frame_num,
+		  __entry->top_field_order_cnt,
+		  __entry->bottom_field_order_cnt,
+		  __entry->idr_pic_id,
+		  __entry->pic_order_cnt_lsb,
+		  __entry->delta_pic_order_cnt_bottom,
+		  __entry->delta_pic_order_cnt0,
+		  __entry->delta_pic_order_cnt1,
+		  __entry->dec_ref_pic_marking_bit_size,
+		  __entry->pic_order_cnt_bit_size,
+		  __entry->slice_group_change_cycle,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
 		  {V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC, "FIELD_PIC"},
 		  {V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD, "BOTTOM_FIELD"},
@@ -622,22 +997,35 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
 	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
 	TP_ARGS(e, i),
-	TP_STRUCT__entry(__field_struct(struct v4l2_h264_dpb_entry, e)
+	TP_STRUCT__entry(__field(u64, reference_ts)
+			 __field(u32, pic_num)
+			 __field(u16, frame_num)
+			 __field(u8, fields)
+			 __field(__s32, top_field_order_cnt)
+			 __field(__s32, bottom_field_order_cnt)
+			 __field(u32, flags)
 			 __field(int, i)),
-	TP_fast_assign(__entry->e = *e; __entry->i = i;),
+	TP_fast_assign(__entry->reference_ts = e->reference_ts;
+		       __entry->pic_num = e->pic_num;
+		       __entry->frame_num = e->frame_num;
+		       __entry->fields = e->fields;
+		       __entry->top_field_order_cnt = e->top_field_order_cnt;
+		       __entry->bottom_field_order_cnt = e->bottom_field_order_cnt;
+		       __entry->flags = e->flags;
+		       __entry->i = i;),
 	TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
 		  "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
 		  __entry->i,
-		  __entry->e.reference_ts,
-		  __entry->e.pic_num,
-		  __entry->e.frame_num,
-		  __print_flags(__entry->e.fields, "|",
+		  __entry->reference_ts,
+		  __entry->pic_num,
+		  __entry->frame_num,
+		  __print_flags(__entry->fields, "|",
 		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
 		  {V4L2_H264_BOTTOM_FIELD_REF, "BOTTOM_FIELD_REF"},
 		  {V4L2_H264_FRAME_REF, "FRAME_REF"}),
-		  __entry->e.top_field_order_cnt,
-		  __entry->e.bottom_field_order_cnt,
-		  __print_flags(__entry->e.flags, "|",
+		  __entry->top_field_order_cnt,
+		  __entry->bottom_field_order_cnt,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_H264_DPB_ENTRY_FLAG_VALID, "VALID"},
 		  {V4L2_H264_DPB_ENTRY_FLAG_ACTIVE, "ACTIVE"},
 		  {V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM, "LONG_TERM"},
@@ -696,8 +1084,68 @@ DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_sps, s)),
-	TP_fast_assign(__entry->s = *s),
+	TP_STRUCT__entry(__field(__u8, video_parameter_set_id)
+			 __field(__u8, seq_parameter_set_id)
+			 __field(__u16, pic_width_in_luma_samples)
+			 __field(__u16, pic_height_in_luma_samples)
+			 __field(__u8, bit_depth_luma_minus8)
+			 __field(__u8, bit_depth_chroma_minus8)
+			 __field(__u8, log2_max_pic_order_cnt_lsb_minus4)
+			 __field(__u8, sps_max_dec_pic_buffering_minus1)
+			 __field(__u8, sps_max_num_reorder_pics)
+			 __field(__u8, sps_max_latency_increase_plus1)
+			 __field(__u8, log2_min_luma_coding_block_size_minus3)
+			 __field(__u8, log2_diff_max_min_luma_coding_block_size)
+			 __field(__u8, log2_min_luma_transform_block_size_minus2)
+			 __field(__u8, log2_diff_max_min_luma_transform_block_size)
+			 __field(__u8, max_transform_hierarchy_depth_inter)
+			 __field(__u8, max_transform_hierarchy_depth_intra)
+			 __field(__u8, pcm_sample_bit_depth_luma_minus1)
+			 __field(__u8, pcm_sample_bit_depth_chroma_minus1)
+			 __field(__u8, log2_min_pcm_luma_coding_block_size_minus3)
+			 __field(__u8, log2_diff_max_min_pcm_luma_coding_block_size)
+			 __field(__u8, num_short_term_ref_pic_sets)
+			 __field(__u8, num_long_term_ref_pics_sps)
+			 __field(__u8, chroma_format_idc)
+			 __field(__u8, sps_max_sub_layers_minus1)
+			 __field(__u64, flags)),
+	TP_fast_assign(__entry->video_parameter_set_id = s->video_parameter_set_id;
+		       __entry->seq_parameter_set_id = s->seq_parameter_set_id;
+		       __entry->pic_width_in_luma_samples = s->pic_width_in_luma_samples;
+		       __entry->pic_height_in_luma_samples = s->pic_height_in_luma_samples;
+		       __entry->bit_depth_luma_minus8 = s->bit_depth_luma_minus8;
+		       __entry->bit_depth_chroma_minus8 = s->bit_depth_chroma_minus8;
+		       __entry->log2_max_pic_order_cnt_lsb_minus4 =
+				s->log2_max_pic_order_cnt_lsb_minus4;
+		       __entry->sps_max_dec_pic_buffering_minus1 =
+				s->sps_max_dec_pic_buffering_minus1;
+		       __entry->sps_max_num_reorder_pics = s->sps_max_num_reorder_pics;
+		       __entry->sps_max_latency_increase_plus1 = s->sps_max_latency_increase_plus1;
+		       __entry->log2_min_luma_coding_block_size_minus3 =
+				s->log2_min_luma_coding_block_size_minus3;
+		       __entry->log2_diff_max_min_luma_coding_block_size =
+				s->log2_diff_max_min_luma_coding_block_size;
+		       __entry->log2_min_luma_transform_block_size_minus2 =
+				s->log2_min_luma_transform_block_size_minus2;
+		       __entry->log2_diff_max_min_luma_transform_block_size =
+				s->log2_diff_max_min_luma_transform_block_size;
+		       __entry->max_transform_hierarchy_depth_inter =
+				s->max_transform_hierarchy_depth_inter;
+		       __entry->max_transform_hierarchy_depth_intra =
+				s->max_transform_hierarchy_depth_intra;
+		       __entry->pcm_sample_bit_depth_luma_minus1 =
+				s->pcm_sample_bit_depth_luma_minus1;
+		       __entry->pcm_sample_bit_depth_chroma_minus1 =
+				s->pcm_sample_bit_depth_chroma_minus1;
+		       __entry->log2_min_pcm_luma_coding_block_size_minus3 =
+				s->log2_min_pcm_luma_coding_block_size_minus3;
+		       __entry->log2_diff_max_min_pcm_luma_coding_block_size =
+				s->log2_diff_max_min_pcm_luma_coding_block_size;
+		       __entry->num_short_term_ref_pic_sets = s->num_short_term_ref_pic_sets;
+		       __entry->num_long_term_ref_pics_sps = s->num_long_term_ref_pics_sps;
+		       __entry->chroma_format_idc = s->chroma_format_idc;
+		       __entry->sps_max_sub_layers_minus1 = s->sps_max_sub_layers_minus1;
+		       __entry->flags = s->flags;),
 	TP_printk("\nvideo_parameter_set_id %u\n"
 		  "seq_parameter_set_id %u\n"
 		  "pic_width_in_luma_samples %u\n"
@@ -723,40 +1171,42 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 		  "chroma_format_idc %u\n"
 		  "sps_max_sub_layers_minus1 %u\n"
 		  "flags %s",
-		  __entry->s.video_parameter_set_id,
-		  __entry->s.seq_parameter_set_id,
-		  __entry->s.pic_width_in_luma_samples,
-		  __entry->s.pic_height_in_luma_samples,
-		  __entry->s.bit_depth_luma_minus8,
-		  __entry->s.bit_depth_chroma_minus8,
-		  __entry->s.log2_max_pic_order_cnt_lsb_minus4,
-		  __entry->s.sps_max_dec_pic_buffering_minus1,
-		  __entry->s.sps_max_num_reorder_pics,
-		  __entry->s.sps_max_latency_increase_plus1,
-		  __entry->s.log2_min_luma_coding_block_size_minus3,
-		  __entry->s.log2_diff_max_min_luma_coding_block_size,
-		  __entry->s.log2_min_luma_transform_block_size_minus2,
-		  __entry->s.log2_diff_max_min_luma_transform_block_size,
-		  __entry->s.max_transform_hierarchy_depth_inter,
-		  __entry->s.max_transform_hierarchy_depth_intra,
-		  __entry->s.pcm_sample_bit_depth_luma_minus1,
-		  __entry->s.pcm_sample_bit_depth_chroma_minus1,
-		  __entry->s.log2_min_pcm_luma_coding_block_size_minus3,
-		  __entry->s.log2_diff_max_min_pcm_luma_coding_block_size,
-		  __entry->s.num_short_term_ref_pic_sets,
-		  __entry->s.num_long_term_ref_pics_sps,
-		  __entry->s.chroma_format_idc,
-		  __entry->s.sps_max_sub_layers_minus1,
-		  __print_flags(__entry->s.flags, "|",
+		  __entry->video_parameter_set_id,
+		  __entry->seq_parameter_set_id,
+		  __entry->pic_width_in_luma_samples,
+		  __entry->pic_height_in_luma_samples,
+		  __entry->bit_depth_luma_minus8,
+		  __entry->bit_depth_chroma_minus8,
+		  __entry->log2_max_pic_order_cnt_lsb_minus4,
+		  __entry->sps_max_dec_pic_buffering_minus1,
+		  __entry->sps_max_num_reorder_pics,
+		  __entry->sps_max_latency_increase_plus1,
+		  __entry->log2_min_luma_coding_block_size_minus3,
+		  __entry->log2_diff_max_min_luma_coding_block_size,
+		  __entry->log2_min_luma_transform_block_size_minus2,
+		  __entry->log2_diff_max_min_luma_transform_block_size,
+		  __entry->max_transform_hierarchy_depth_inter,
+		  __entry->max_transform_hierarchy_depth_intra,
+		  __entry->pcm_sample_bit_depth_luma_minus1,
+		  __entry->pcm_sample_bit_depth_chroma_minus1,
+		  __entry->log2_min_pcm_luma_coding_block_size_minus3,
+		  __entry->log2_diff_max_min_pcm_luma_coding_block_size,
+		  __entry->num_short_term_ref_pic_sets,
+		  __entry->num_long_term_ref_pics_sps,
+		  __entry->chroma_format_idc,
+		  __entry->sps_max_sub_layers_minus1,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE, "SEPARATE_COLOUR_PLANE"},
 		  {V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED, "SCALING_LIST_ENABLED"},
 		  {V4L2_HEVC_SPS_FLAG_AMP_ENABLED, "AMP_ENABLED"},
 		  {V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET, "SAMPLE_ADAPTIVE_OFFSET"},
 		  {V4L2_HEVC_SPS_FLAG_PCM_ENABLED, "PCM_ENABLED"},
-		  {V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED, "V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED"},
+		  {V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED,
+		   "V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED"},
 		  {V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT, "LONG_TERM_REF_PICS_PRESENT"},
 		  {V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED, "TEMPORAL_MVP_ENABLED"},
-		  {V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED, "STRONG_INTRA_SMOOTHING_ENABLED"}
+		  {V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED,
+		   "STRONG_INTRA_SMOOTHING_ENABLED"}
 	))
 
 );
@@ -765,8 +1215,43 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
 	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_pps, p)),
-	TP_fast_assign(__entry->p = *p),
+	TP_STRUCT__entry(__field(__u8, pic_parameter_set_id)
+			 __field(__u8, num_extra_slice_header_bits)
+			 __field(__u8, num_ref_idx_l0_default_active_minus1)
+			 __field(__u8, num_ref_idx_l1_default_active_minus1)
+			 __field(__s8, init_qp_minus26)
+			 __field(__u8, diff_cu_qp_delta_depth)
+			 __field(__s8, pps_cb_qp_offset)
+			 __field(__s8, pps_cr_qp_offset)
+			 __field(__u8, num_tile_columns_minus1)
+			 __field(__u8, num_tile_rows_minus1)
+			 __array(__u8, column_width_minus1, 20)
+			 __array(__u8, row_height_minus1, 22)
+			 __field(__s8, pps_beta_offset_div2)
+			 __field(__s8, pps_tc_offset_div2)
+			 __field(__u8, log2_parallel_merge_level_minus2)
+			 __field(__u64, flags)),
+	TP_fast_assign(__entry->pic_parameter_set_id = p->pic_parameter_set_id;
+		       __entry->num_extra_slice_header_bits = p->num_extra_slice_header_bits;
+		       __entry->num_ref_idx_l0_default_active_minus1 =
+				p->num_ref_idx_l0_default_active_minus1;
+		       __entry->num_ref_idx_l1_default_active_minus1 =
+				p->num_ref_idx_l1_default_active_minus1;
+		       __entry->init_qp_minus26 = p->init_qp_minus26;
+		       __entry->diff_cu_qp_delta_depth = p->diff_cu_qp_delta_depth;
+		       __entry->pps_cb_qp_offset = p->pps_cb_qp_offset;
+		       __entry->pps_cr_qp_offset = p->pps_cr_qp_offset;
+		       __entry->num_tile_columns_minus1 = p->num_tile_columns_minus1;
+		       __entry->num_tile_rows_minus1 = p->num_tile_rows_minus1;
+		       memcpy(__entry->column_width_minus1, p->column_width_minus1,
+			      sizeof(__entry->column_width_minus1));
+		       memcpy(__entry->row_height_minus1, p->row_height_minus1,
+			      sizeof(__entry->row_height_minus1));
+		       __entry->pps_beta_offset_div2 = p->pps_beta_offset_div2;
+		       __entry->pps_tc_offset_div2 = p->pps_tc_offset_div2;
+		       __entry->log2_parallel_merge_level_minus2 =
+				p->log2_parallel_merge_level_minus2;
+		       __entry->flags = p->flags;),
 	TP_printk("\npic_parameter_set_id %u\n"
 		  "num_extra_slice_header_bits %u\n"
 		  "num_ref_idx_l0_default_active_minus1 %u\n"
@@ -783,45 +1268,52 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 		  "pps_tc_offset_div2 %d\n"
 		  "log2_parallel_merge_level_minus2 %u\n"
 		  "flags %s",
-		  __entry->p.pic_parameter_set_id,
-		  __entry->p.num_extra_slice_header_bits,
-		  __entry->p.num_ref_idx_l0_default_active_minus1,
-		  __entry->p.num_ref_idx_l1_default_active_minus1,
-		  __entry->p.init_qp_minus26,
-		  __entry->p.diff_cu_qp_delta_depth,
-		  __entry->p.pps_cb_qp_offset,
-		  __entry->p.pps_cr_qp_offset,
-		  __entry->p.num_tile_columns_minus1,
-		  __entry->p.num_tile_rows_minus1,
-		  __print_array(__entry->p.column_width_minus1,
-				ARRAY_SIZE(__entry->p.column_width_minus1),
-				sizeof(__entry->p.column_width_minus1[0])),
-		  __print_array(__entry->p.row_height_minus1,
-				ARRAY_SIZE(__entry->p.row_height_minus1),
-				sizeof(__entry->p.row_height_minus1[0])),
-		  __entry->p.pps_beta_offset_div2,
-		  __entry->p.pps_tc_offset_div2,
-		  __entry->p.log2_parallel_merge_level_minus2,
-		  __print_flags(__entry->p.flags, "|",
-		  {V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED, "DEPENDENT_SLICE_SEGMENT_ENABLED"},
+		  __entry->pic_parameter_set_id,
+		  __entry->num_extra_slice_header_bits,
+		  __entry->num_ref_idx_l0_default_active_minus1,
+		  __entry->num_ref_idx_l1_default_active_minus1,
+		  __entry->init_qp_minus26,
+		  __entry->diff_cu_qp_delta_depth,
+		  __entry->pps_cb_qp_offset,
+		  __entry->pps_cr_qp_offset,
+		  __entry->num_tile_columns_minus1,
+		  __entry->num_tile_rows_minus1,
+		  __print_array(__entry->column_width_minus1,
+				ARRAY_SIZE(__entry->column_width_minus1),
+				sizeof(__entry->column_width_minus1[0])),
+		  __print_array(__entry->row_height_minus1,
+				ARRAY_SIZE(__entry->row_height_minus1),
+				sizeof(__entry->row_height_minus1[0])),
+		  __entry->pps_beta_offset_div2,
+		  __entry->pps_tc_offset_div2,
+		  __entry->log2_parallel_merge_level_minus2,
+		  __print_flags(__entry->flags, "|",
+		  {V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED,
+		   "DEPENDENT_SLICE_SEGMENT_ENABLED"},
 		  {V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT, "OUTPUT_FLAG_PRESENT"},
 		  {V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED, "SIGN_DATA_HIDING_ENABLED"},
 		  {V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT, "CABAC_INIT_PRESENT"},
 		  {V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED, "CONSTRAINED_INTRA_PRED"},
 		  {V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED, "CU_QP_DELTA_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT, "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT,
+		   "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT"},
 		  {V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED, "WEIGHTED_PRED"},
 		  {V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED, "WEIGHTED_BIPRED"},
 		  {V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED, "TRANSQUANT_BYPASS_ENABLED"},
 		  {V4L2_HEVC_PPS_FLAG_TILES_ENABLED, "TILES_ENABLED"},
 		  {V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED, "ENTROPY_CODING_SYNC_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED, "LOOP_FILTER_ACROSS_TILES_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED, "PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
-		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED, "DEBLOCKING_FILTER_OVERRIDE_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED,
+		   "LOOP_FILTER_ACROSS_TILES_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED,
+		   "PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
+		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED,
+		   "DEBLOCKING_FILTER_OVERRIDE_ENABLED"},
 		  {V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER, "DISABLE_DEBLOCKING_FILTER"},
 		  {V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT, "LISTS_MODIFICATION_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT, "SLICE_SEGMENT_HEADER_EXTENSION_PRESENT"},
-		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT, "DEBLOCKING_FILTER_CONTROL_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT,
+		   "SLICE_SEGMENT_HEADER_EXTENSION_PRESENT"},
+		  {V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT,
+		   "DEBLOCKING_FILTER_CONTROL_PRESENT"},
 		  {V4L2_HEVC_PPS_FLAG_UNIFORM_SPACING, "UNIFORM_SPACING"}
 	))
 
@@ -832,8 +1324,60 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_slice_params, s)),
-	TP_fast_assign(__entry->s = *s),
+	TP_STRUCT__entry(__field(__u32, bit_size)
+			 __field(__u32, data_byte_offset)
+			 __field(__u32, num_entry_point_offsets)
+			 __field(__u8, nal_unit_type)
+			 __field(__u8, nuh_temporal_id_plus1)
+			 __field(__u8, slice_type)
+			 __field(__u8, colour_plane_id)
+			 __field(__s32, slice_pic_order_cnt)
+			 __field(__u8, num_ref_idx_l0_active_minus1)
+			 __field(__u8, num_ref_idx_l1_active_minus1)
+			 __field(__u8, collocated_ref_idx)
+			 __field(__u8, five_minus_max_num_merge_cand)
+			 __field(__s8, slice_qp_delta)
+			 __field(__s8, slice_cb_qp_offset)
+			 __field(__s8, slice_cr_qp_offset)
+			 __field(__s8, slice_act_y_qp_offset)
+			 __field(__s8, slice_act_cb_qp_offset)
+			 __field(__s8, slice_act_cr_qp_offset)
+			 __field(__s8, slice_beta_offset_div2)
+			 __field(__s8, slice_tc_offset_div2)
+			 __field(__u8, pic_struct)
+			 __field(__u32, slice_segment_addr)
+			 __array(__u8, ref_idx_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__u8, ref_idx_l1, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __field(__u16, short_term_ref_pic_set_size)
+			 __field(__u16, long_term_ref_pic_set_size)
+			 __field(__u64, flags)),
+	TP_fast_assign(__entry->bit_size = s->bit_size;
+		       __entry->data_byte_offset = s->data_byte_offset;
+		       __entry->num_entry_point_offsets = s->num_entry_point_offsets;
+		       __entry->nal_unit_type = s->nal_unit_type;
+		       __entry->nuh_temporal_id_plus1 = s->nuh_temporal_id_plus1;
+		       __entry->slice_type = s->slice_type;
+		       __entry->colour_plane_id = s->colour_plane_id;
+		       __entry->slice_pic_order_cnt = s->slice_pic_order_cnt;
+		       __entry->num_ref_idx_l0_active_minus1 = s->num_ref_idx_l0_active_minus1;
+		       __entry->num_ref_idx_l1_active_minus1 = s->num_ref_idx_l1_active_minus1;
+		       __entry->collocated_ref_idx = s->collocated_ref_idx;
+		       __entry->five_minus_max_num_merge_cand = s->five_minus_max_num_merge_cand;
+		       __entry->slice_qp_delta = s->slice_qp_delta;
+		       __entry->slice_cb_qp_offset = s->slice_cb_qp_offset;
+		       __entry->slice_cr_qp_offset = s->slice_cr_qp_offset;
+		       __entry->slice_act_y_qp_offset = s->slice_act_y_qp_offset;
+		       __entry->slice_act_cb_qp_offset = s->slice_act_cb_qp_offset;
+		       __entry->slice_act_cr_qp_offset = s->slice_act_cr_qp_offset;
+		       __entry->slice_beta_offset_div2 = s->slice_beta_offset_div2;
+		       __entry->slice_tc_offset_div2 = s->slice_tc_offset_div2;
+		       __entry->pic_struct = s->pic_struct;
+		       __entry->slice_segment_addr = s->slice_segment_addr;
+		       memcpy(__entry->ref_idx_l0, s->ref_idx_l0, sizeof(__entry->ref_idx_l0));
+		       memcpy(__entry->ref_idx_l1, s->ref_idx_l1, sizeof(__entry->ref_idx_l1));
+		       __entry->short_term_ref_pic_set_size = s->short_term_ref_pic_set_size;
+		       __entry->long_term_ref_pic_set_size = s->long_term_ref_pic_set_size;
+		       __entry->flags = s->flags;),
 	TP_printk("\nbit_size %u\n"
 		  "data_byte_offset %u\n"
 		  "num_entry_point_offsets %u\n"
@@ -861,46 +1405,49 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 		  "short_term_ref_pic_set_size %u\n"
 		  "long_term_ref_pic_set_size %u\n"
 		  "flags %s",
-		  __entry->s.bit_size,
-		  __entry->s.data_byte_offset,
-		  __entry->s.num_entry_point_offsets,
-		  __entry->s.nal_unit_type,
-		  __entry->s.nuh_temporal_id_plus1,
-		  __entry->s.slice_type,
-		  __entry->s.colour_plane_id,
-		  __entry->s.slice_pic_order_cnt,
-		  __entry->s.num_ref_idx_l0_active_minus1,
-		  __entry->s.num_ref_idx_l1_active_minus1,
-		  __entry->s.collocated_ref_idx,
-		  __entry->s.five_minus_max_num_merge_cand,
-		  __entry->s.slice_qp_delta,
-		  __entry->s.slice_cb_qp_offset,
-		  __entry->s.slice_cr_qp_offset,
-		  __entry->s.slice_act_y_qp_offset,
-		  __entry->s.slice_act_cb_qp_offset,
-		  __entry->s.slice_act_cr_qp_offset,
-		  __entry->s.slice_beta_offset_div2,
-		  __entry->s.slice_tc_offset_div2,
-		  __entry->s.pic_struct,
-		  __entry->s.slice_segment_addr,
-		  __print_array(__entry->s.ref_idx_l0,
-				ARRAY_SIZE(__entry->s.ref_idx_l0),
-				sizeof(__entry->s.ref_idx_l0[0])),
-		  __print_array(__entry->s.ref_idx_l1,
-				ARRAY_SIZE(__entry->s.ref_idx_l1),
-				sizeof(__entry->s.ref_idx_l1[0])),
-		  __entry->s.short_term_ref_pic_set_size,
-		  __entry->s.long_term_ref_pic_set_size,
-		  __print_flags(__entry->s.flags, "|",
+		  __entry->bit_size,
+		  __entry->data_byte_offset,
+		  __entry->num_entry_point_offsets,
+		  __entry->nal_unit_type,
+		  __entry->nuh_temporal_id_plus1,
+		  __entry->slice_type,
+		  __entry->colour_plane_id,
+		  __entry->slice_pic_order_cnt,
+		  __entry->num_ref_idx_l0_active_minus1,
+		  __entry->num_ref_idx_l1_active_minus1,
+		  __entry->collocated_ref_idx,
+		  __entry->five_minus_max_num_merge_cand,
+		  __entry->slice_qp_delta,
+		  __entry->slice_cb_qp_offset,
+		  __entry->slice_cr_qp_offset,
+		  __entry->slice_act_y_qp_offset,
+		  __entry->slice_act_cb_qp_offset,
+		  __entry->slice_act_cr_qp_offset,
+		  __entry->slice_beta_offset_div2,
+		  __entry->slice_tc_offset_div2,
+		  __entry->pic_struct,
+		  __entry->slice_segment_addr,
+		  __print_array(__entry->ref_idx_l0,
+				ARRAY_SIZE(__entry->ref_idx_l0),
+				sizeof(__entry->ref_idx_l0[0])),
+		  __print_array(__entry->ref_idx_l1,
+				ARRAY_SIZE(__entry->ref_idx_l1),
+				sizeof(__entry->ref_idx_l1[0])),
+		  __entry->short_term_ref_pic_set_size,
+		  __entry->long_term_ref_pic_set_size,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA, "SLICE_SAO_LUMA"},
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA, "SLICE_SAO_CHROMA"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED, "SLICE_TEMPORAL_MVP_ENABLED"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED,
+		   "SLICE_TEMPORAL_MVP_ENABLED"},
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO, "MVD_L1_ZERO"},
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT, "CABAC_INIT"},
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0, "COLLOCATED_FROM_L0"},
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV, "USE_INTEGER_MV"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED, "SLICE_DEBLOCKING_FILTER_DISABLED"},
-		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED, "SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED,
+		   "SLICE_DEBLOCKING_FILTER_DISABLED"},
+		  {V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED,
+		   "SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED"},
 		  {V4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENT, "DEPENDENT_SLICE_SEGMENT"}
 
 	))
@@ -909,8 +1456,35 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
 	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
 	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_hevc_pred_weight_table, p)),
-	TP_fast_assign(__entry->p = *p),
+	TP_STRUCT__entry(__array(__s8, delta_luma_weight_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__s8, luma_offset_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__s8, delta_chroma_weight_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
+			 __array(__s8, chroma_offset_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
+			 __array(__s8, delta_luma_weight_l1, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__s8, luma_offset_l1, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__s8, delta_chroma_weight_l1, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
+			 __array(__s8, chroma_offset_l1, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
+			 __field(__u8, luma_log2_weight_denom)
+			 __field(__s8, delta_chroma_log2_weight_denom)),
+	TP_fast_assign(memcpy(__entry->delta_luma_weight_l0, p->delta_luma_weight_l0,
+			      sizeof(__entry->delta_luma_weight_l0));
+		       memcpy(__entry->luma_offset_l0, p->luma_offset_l0,
+			      sizeof(__entry->luma_offset_l0));
+		       memcpy(__entry->delta_chroma_weight_l0, p->delta_chroma_weight_l0,
+			      sizeof(__entry->delta_chroma_weight_l0));
+		       memcpy(__entry->chroma_offset_l0, p->chroma_offset_l0,
+			      sizeof(__entry->chroma_offset_l0));
+		       memcpy(__entry->delta_luma_weight_l1, p->delta_luma_weight_l1,
+			      sizeof(__entry->delta_luma_weight_l1));
+		       memcpy(__entry->luma_offset_l1, p->luma_offset_l1,
+			      sizeof(__entry->luma_offset_l1));
+		       memcpy(__entry->delta_chroma_weight_l1, p->delta_chroma_weight_l1,
+			      sizeof(__entry->delta_chroma_weight_l1));
+		       memcpy(__entry->chroma_offset_l1, p->chroma_offset_l1,
+			      sizeof(__entry->chroma_offset_l1));
+		       __entry->luma_log2_weight_denom = p->luma_log2_weight_denom;
+		       __entry->delta_chroma_log2_weight_denom =
+				p->delta_chroma_log2_weight_denom;),
 	TP_printk("\ndelta_luma_weight_l0 %s\n"
 		  "luma_offset_l0 %s\n"
 		  "delta_chroma_weight_l0 {%s}\n"
@@ -921,44 +1495,62 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
 		  "chroma_offset_l1 {%s}\n"
 		  "luma_log2_weight_denom %d\n"
 		  "delta_chroma_log2_weight_denom %d\n",
-		  __print_array(__entry->p.delta_luma_weight_l0,
-				ARRAY_SIZE(__entry->p.delta_luma_weight_l0),
-				sizeof(__entry->p.delta_luma_weight_l0[0])),
-		  __print_array(__entry->p.luma_offset_l0,
-				ARRAY_SIZE(__entry->p.luma_offset_l0),
-				sizeof(__entry->p.luma_offset_l0[0])),
+		  __print_array(__entry->delta_luma_weight_l0,
+				ARRAY_SIZE(__entry->delta_luma_weight_l0),
+				sizeof(__entry->delta_luma_weight_l0[0])),
+		  __print_array(__entry->luma_offset_l0,
+				ARRAY_SIZE(__entry->luma_offset_l0),
+				sizeof(__entry->luma_offset_l0[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.delta_chroma_weight_l0,
-				   sizeof(__entry->p.delta_chroma_weight_l0),
+				   __entry->delta_chroma_weight_l0,
+				   sizeof(__entry->delta_chroma_weight_l0),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.chroma_offset_l0,
-				   sizeof(__entry->p.chroma_offset_l0),
+				   __entry->chroma_offset_l0,
+				   sizeof(__entry->chroma_offset_l0),
 				   false),
-		  __print_array(__entry->p.delta_luma_weight_l1,
-				ARRAY_SIZE(__entry->p.delta_luma_weight_l1),
-				sizeof(__entry->p.delta_luma_weight_l1[0])),
-		  __print_array(__entry->p.luma_offset_l1,
-				ARRAY_SIZE(__entry->p.luma_offset_l1),
-				sizeof(__entry->p.luma_offset_l1[0])),
+		  __print_array(__entry->delta_luma_weight_l1,
+				ARRAY_SIZE(__entry->delta_luma_weight_l1),
+				sizeof(__entry->delta_luma_weight_l1[0])),
+		  __print_array(__entry->luma_offset_l1,
+				ARRAY_SIZE(__entry->luma_offset_l1),
+				sizeof(__entry->luma_offset_l1[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.delta_chroma_weight_l1,
-				   sizeof(__entry->p.delta_chroma_weight_l1),
+				   __entry->delta_chroma_weight_l1,
+				   sizeof(__entry->delta_chroma_weight_l1),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.chroma_offset_l1,
-				   sizeof(__entry->p.chroma_offset_l1),
+				   __entry->chroma_offset_l1,
+				   sizeof(__entry->chroma_offset_l1),
 				   false),
-		__entry->p.luma_log2_weight_denom,
-		__entry->p.delta_chroma_log2_weight_denom
+		__entry->luma_log2_weight_denom,
+		__entry->delta_chroma_log2_weight_denom
 
 	))
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_scaling_matrix, s)),
-	TP_fast_assign(__entry->s = *s),
+	TP_STRUCT__entry(__array(__u8, scaling_list_4x4, 6 * 16)
+			 __array(__u8, scaling_list_8x8, 6 * 64)
+			 __array(__u8, scaling_list_16x16, 6 * 64)
+			 __array(__u8, scaling_list_32x32, 2 * 64)
+			 __array(__u8, scaling_list_dc_coef_16x16, 6)
+			 __array(__u8, scaling_list_dc_coef_32x32, 2)),
+	TP_fast_assign(memcpy(__entry->scaling_list_4x4,
+			      s->scaling_list_4x4, sizeof(__entry->scaling_list_4x4));
+		       memcpy(__entry->scaling_list_8x8,
+			      s->scaling_list_8x8, sizeof(__entry->scaling_list_8x8));
+		       memcpy(__entry->scaling_list_16x16,
+			      s->scaling_list_16x16, sizeof(__entry->scaling_list_16x16));
+		       memcpy(__entry->scaling_list_32x32,
+			      s->scaling_list_32x32, sizeof(__entry->scaling_list_32x32));
+		       memcpy(__entry->scaling_list_dc_coef_16x16,
+			      s->scaling_list_dc_coef_16x16,
+			      sizeof(__entry->scaling_list_dc_coef_16x16));
+		       memcpy(__entry->scaling_list_dc_coef_32x32,
+			      s->scaling_list_dc_coef_32x32,
+			      sizeof(__entry->scaling_list_dc_coef_32x32));),
 	TP_printk("\nscaling_list_4x4 {%s}\n"
 		  "scaling_list_8x8 {%s}\n"
 		  "scaling_list_16x16 {%s}\n"
@@ -966,34 +1558,56 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
 		  "scaling_list_dc_coef_16x16 %s\n"
 		  "scaling_list_dc_coef_32x32 %s\n",
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_4x4,
-				   sizeof(__entry->s.scaling_list_4x4),
+				   __entry->scaling_list_4x4,
+				   sizeof(__entry->scaling_list_4x4),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_8x8,
-				   sizeof(__entry->s.scaling_list_8x8),
+				   __entry->scaling_list_8x8,
+				   sizeof(__entry->scaling_list_8x8),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_16x16,
-				   sizeof(__entry->s.scaling_list_16x16),
+				   __entry->scaling_list_16x16,
+				   sizeof(__entry->scaling_list_16x16),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->s.scaling_list_32x32,
-				   sizeof(__entry->s.scaling_list_32x32),
+				   __entry->scaling_list_32x32,
+				   sizeof(__entry->scaling_list_32x32),
 				   false),
-		  __print_array(__entry->s.scaling_list_dc_coef_16x16,
-				ARRAY_SIZE(__entry->s.scaling_list_dc_coef_16x16),
-				sizeof(__entry->s.scaling_list_dc_coef_16x16[0])),
-		  __print_array(__entry->s.scaling_list_dc_coef_32x32,
-				ARRAY_SIZE(__entry->s.scaling_list_dc_coef_32x32),
-				sizeof(__entry->s.scaling_list_dc_coef_32x32[0]))
+		  __print_array(__entry->scaling_list_dc_coef_16x16,
+				ARRAY_SIZE(__entry->scaling_list_dc_coef_16x16),
+				sizeof(__entry->scaling_list_dc_coef_16x16[0])),
+		  __print_array(__entry->scaling_list_dc_coef_32x32,
+				ARRAY_SIZE(__entry->scaling_list_dc_coef_32x32),
+				sizeof(__entry->scaling_list_dc_coef_32x32[0]))
 	))
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
 	TP_ARGS(d),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_decode_params, d)),
-	TP_fast_assign(__entry->d = *d),
+	TP_STRUCT__entry(__field(__s32, pic_order_cnt_val)
+			 __field(__u16, short_term_ref_pic_set_size)
+			 __field(__u16, long_term_ref_pic_set_size)
+			 __field(__u8, num_active_dpb_entries)
+			 __field(__u8, num_poc_st_curr_before)
+			 __field(__u8, num_poc_st_curr_after)
+			 __field(__u8, num_poc_lt_curr)
+			 __array(__u8, poc_st_curr_before, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__u8, poc_st_curr_after, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __array(__u8, poc_lt_curr, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+			 __field(__u64, flags)),
+	TP_fast_assign(__entry->pic_order_cnt_val = d->pic_order_cnt_val;
+		       __entry->short_term_ref_pic_set_size = d->short_term_ref_pic_set_size;
+		       __entry->long_term_ref_pic_set_size = d->long_term_ref_pic_set_size;
+		       __entry->num_active_dpb_entries = d->num_active_dpb_entries;
+		       __entry->num_poc_st_curr_before = d->num_poc_st_curr_before;
+		       __entry->num_poc_st_curr_after = d->num_poc_st_curr_after;
+		       __entry->num_poc_lt_curr = d->num_poc_lt_curr;
+		       memcpy(__entry->poc_st_curr_before, d->poc_st_curr_before,
+			      sizeof(__entry->poc_st_curr_before));
+		       memcpy(__entry->poc_st_curr_after, d->poc_st_curr_after,
+			      sizeof(__entry->poc_st_curr_after));
+		       memcpy(__entry->poc_lt_curr, d->poc_lt_curr, sizeof(__entry->poc_lt_curr));
+		       __entry->flags = d->flags;),
 	TP_printk("\npic_order_cnt_val %d\n"
 		  "short_term_ref_pic_set_size %u\n"
 		  "long_term_ref_pic_set_size %u\n"
@@ -1005,23 +1619,23 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 		  "poc_st_curr_after %s\n"
 		  "poc_lt_curr %s\n"
 		  "flags %s",
-		  __entry->d.pic_order_cnt_val,
-		  __entry->d.short_term_ref_pic_set_size,
-		  __entry->d.long_term_ref_pic_set_size,
-		  __entry->d.num_active_dpb_entries,
-		  __entry->d.num_poc_st_curr_before,
-		  __entry->d.num_poc_st_curr_after,
-		  __entry->d.num_poc_lt_curr,
-		  __print_array(__entry->d.poc_st_curr_before,
-				ARRAY_SIZE(__entry->d.poc_st_curr_before),
-				sizeof(__entry->d.poc_st_curr_before[0])),
-		  __print_array(__entry->d.poc_st_curr_after,
-				ARRAY_SIZE(__entry->d.poc_st_curr_after),
-				sizeof(__entry->d.poc_st_curr_after[0])),
-		  __print_array(__entry->d.poc_lt_curr,
-				ARRAY_SIZE(__entry->d.poc_lt_curr),
-				sizeof(__entry->d.poc_lt_curr[0])),
-		  __print_flags(__entry->d.flags, "|",
+		  __entry->pic_order_cnt_val,
+		  __entry->short_term_ref_pic_set_size,
+		  __entry->long_term_ref_pic_set_size,
+		  __entry->num_active_dpb_entries,
+		  __entry->num_poc_st_curr_before,
+		  __entry->num_poc_st_curr_after,
+		  __entry->num_poc_lt_curr,
+		  __print_array(__entry->poc_st_curr_before,
+				ARRAY_SIZE(__entry->poc_st_curr_before),
+				sizeof(__entry->poc_st_curr_before[0])),
+		  __print_array(__entry->poc_st_curr_after,
+				ARRAY_SIZE(__entry->poc_st_curr_after),
+				sizeof(__entry->poc_st_curr_after[0])),
+		  __print_array(__entry->poc_lt_curr,
+				ARRAY_SIZE(__entry->poc_lt_curr),
+				sizeof(__entry->poc_lt_curr[0])),
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PIC, "IRAP_PIC"},
 		  {V4L2_HEVC_DECODE_PARAM_FLAG_IDR_PIC, "IDR_PIC"},
 		  {V4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIOR, "NO_OUTPUT_OF_PRIOR"}
@@ -1031,22 +1645,44 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
 	TP_ARGS(lt),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_lt_rps, lt)),
-	TP_fast_assign(__entry->lt = *lt),
+	TP_STRUCT__entry(__field(__u8, flags)
+			 __field(__u32, lt_ref_pic_poc_lsb_sps)),
+	TP_fast_assign(__entry->flags = lt->flags;
+		       __entry->lt_ref_pic_poc_lsb_sps = lt->lt_ref_pic_poc_lsb_sps;),
 	TP_printk("\nflags %s\n"
 		  "lt_ref_pic_poc_lsb_sps %x\n",
-		  __print_flags(__entry->lt.flags, "|",
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
 		  ),
-		  __entry->lt.lt_ref_pic_poc_lsb_sps
+		  __entry->lt_ref_pic_poc_lsb_sps
 	)
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
 	TP_ARGS(st),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_hevc_ext_sps_st_rps, st)),
-	TP_fast_assign(__entry->st = *st),
+	TP_STRUCT__entry(__field(__u8, flags)
+			 __field(__u8, delta_idx_minus1)
+			 __field(__u8, delta_rps_sign)
+			 __field(__u16, abs_delta_rps_minus1)
+			 __field(__u8, num_negative_pics)
+			 __field(__u8, num_positive_pics)
+			 __field(__u32, used_by_curr_pic)
+			 __field(__u32, use_delta_flag)
+			 __array(__u32, delta_poc_s0_minus1, 16)
+			 __array(__u32, delta_poc_s1_minus1, 16)),
+	TP_fast_assign(__entry->flags = st->flags;
+		       __entry->delta_idx_minus1 = st->delta_idx_minus1;
+		       __entry->delta_rps_sign = st->delta_rps_sign;
+		       __entry->abs_delta_rps_minus1 = st->abs_delta_rps_minus1;
+		       __entry->num_negative_pics = st->num_negative_pics;
+		       __entry->num_positive_pics = st->num_positive_pics;
+		       __entry->used_by_curr_pic = st->used_by_curr_pic;
+		       __entry->use_delta_flag = st->use_delta_flag;
+		       memcpy(__entry->delta_poc_s0_minus1, st->delta_poc_s0_minus1,
+			      sizeof(__entry->delta_poc_s0_minus1));
+		       memcpy(__entry->delta_poc_s1_minus1, st->delta_poc_s1_minus1,
+			      sizeof(__entry->delta_poc_s1_minus1));),
 	TP_printk("\nflags %s\n"
 		  "delta_idx_minus1: %u\n"
 		  "delta_rps_sign: %u\n"
@@ -1057,40 +1693,46 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
 		  "use_delta_flag: %08x\n"
 		  "delta_poc_s0_minus1: %s\n"
 		  "delta_poc_s1_minus1: %s\n",
-		  __print_flags(__entry->st.flags, "|",
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
 		  ),
-		  __entry->st.delta_idx_minus1,
-		  __entry->st.delta_rps_sign,
-		  __entry->st.abs_delta_rps_minus1,
-		  __entry->st.num_negative_pics,
-		  __entry->st.num_positive_pics,
-		  __entry->st.used_by_curr_pic,
-		  __entry->st.use_delta_flag,
-		  __print_array(__entry->st.delta_poc_s0_minus1,
-				ARRAY_SIZE(__entry->st.delta_poc_s0_minus1),
-				sizeof(__entry->st.delta_poc_s0_minus1[0])),
-		  __print_array(__entry->st.delta_poc_s1_minus1,
-				ARRAY_SIZE(__entry->st.delta_poc_s1_minus1),
-				sizeof(__entry->st.delta_poc_s1_minus1[0]))
+		  __entry->delta_idx_minus1,
+		  __entry->delta_rps_sign,
+		  __entry->abs_delta_rps_minus1,
+		  __entry->num_negative_pics,
+		  __entry->num_positive_pics,
+		  __entry->used_by_curr_pic,
+		  __entry->use_delta_flag,
+		  __print_array(__entry->delta_poc_s0_minus1,
+				ARRAY_SIZE(__entry->delta_poc_s0_minus1),
+				sizeof(__entry->delta_poc_s0_minus1[0])),
+		  __print_array(__entry->delta_poc_s1_minus1,
+				ARRAY_SIZE(__entry->delta_poc_s1_minus1),
+				sizeof(__entry->delta_poc_s1_minus1[0]))
 	)
 );
 
 DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
 	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
 	TP_ARGS(e),
-	TP_STRUCT__entry(__field_struct(struct v4l2_hevc_dpb_entry, e)),
-	TP_fast_assign(__entry->e = *e),
+	TP_STRUCT__entry(__field(__u64, timestamp)
+			 __field(__u8, flags)
+			 __field(__u8, field_pic)
+			 __field(__s32, pic_order_cnt_val)),
+	TP_fast_assign(__entry->timestamp = e->timestamp;
+		       __entry->flags = e->flags;
+		       __entry->field_pic = e->field_pic;
+		       __entry->pic_order_cnt_val = e->pic_order_cnt_val;),
 	TP_printk("\ntimestamp %llu\n"
 		  "flags %s\n"
 		  "field_pic %u\n"
 		  "pic_order_cnt_val %d\n",
-		__entry->e.timestamp,
-		__print_flags(__entry->e.flags, "|",
+		__entry->timestamp,
+		__print_flags(__entry->flags, "|",
 		{V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
 		  ),
-		__entry->e.field_pic,
-		__entry->e.pic_order_cnt_val
+		__entry->field_pic,
+		__entry->pic_order_cnt_val
 	))
 
 DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
@@ -1143,16 +1785,26 @@ DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
 DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
 	TP_ARGS(s),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_sequence, s)),
-	TP_fast_assign(__entry->s = *s;),
+	TP_STRUCT__entry(__field(__u16, horizontal_size)
+			 __field(__u16, vertical_size)
+			 __field(__u32, vbv_buffer_size)
+			 __field(__u16, profile_and_level_indication)
+			 __field(__u8, chroma_format)
+			 __field(__u8, flags)),
+	TP_fast_assign(__entry->horizontal_size = s->horizontal_size;
+		       __entry->vertical_size = s->vertical_size;
+		       __entry->vbv_buffer_size = s->vbv_buffer_size;
+		       __entry->profile_and_level_indication = s->profile_and_level_indication;
+		       __entry->chroma_format = s->chroma_format;
+		       __entry->flags = s->flags;),
 	TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
 		  "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
-		  __entry->s.horizontal_size,
-		  __entry->s.vertical_size,
-		  __entry->s.vbv_buffer_size,
-		  __entry->s.profile_and_level_indication,
-		  __entry->s.chroma_format,
-		  __print_flags(__entry->s.flags, "|",
+		  __entry->horizontal_size,
+		  __entry->vertical_size,
+		  __entry->vbv_buffer_size,
+		  __entry->profile_and_level_indication,
+		  __entry->chroma_format,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE, "PROGRESSIVE"})
 	)
 );
@@ -1160,13 +1812,25 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
 	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_picture, p)),
-	TP_fast_assign(__entry->p = *p;),
+	TP_STRUCT__entry(__field(__u64, backward_ref_ts)
+			 __field(__u64, forward_ref_ts)
+			 __field(__u32, flags)
+			 __array(__u8, f_code, 4)
+			 __field(__u8, picture_coding_type)
+			 __field(__u8, picture_structure)
+			 __field(__u8, intra_dc_precision)),
+	TP_fast_assign(__entry->backward_ref_ts = p->backward_ref_ts;
+		       __entry->forward_ref_ts = p->forward_ref_ts;
+		       __entry->flags = p->flags;
+		       memcpy(__entry->f_code, p->f_code, sizeof(__entry->f_code));
+		       __entry->picture_coding_type = p->picture_coding_type;
+		       __entry->picture_structure = p->picture_structure;
+		       __entry->intra_dc_precision = p->intra_dc_precision;),
 	TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
 		  "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
-		  __entry->p.backward_ref_ts,
-		  __entry->p.forward_ref_ts,
-		  __print_flags(__entry->p.flags, "|",
+		  __entry->backward_ref_ts,
+		  __entry->forward_ref_ts,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST, "TOP_FIELD_FIRST"},
 		  {V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT, "FRAME_PRED_DCT"},
 		  {V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV, "CONCEALMENT_MV"},
@@ -1176,34 +1840,46 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
 		  {V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST, "REPEAT_FIRST"},
 		  {V4L2_MPEG2_PIC_FLAG_PROGRESSIVE, "PROGRESSIVE"}),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.f_code,
-				   sizeof(__entry->p.f_code),
+				   __entry->f_code,
+				   sizeof(__entry->f_code),
 				   false),
-		  __entry->p.picture_coding_type,
-		  __entry->p.picture_structure,
-		  __entry->p.intra_dc_precision
+		  __entry->picture_coding_type,
+		  __entry->picture_structure,
+		  __entry->intra_dc_precision
 	)
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
 	TP_ARGS(q),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_mpeg2_quantisation, q)),
-	TP_fast_assign(__entry->q = *q;),
+	TP_STRUCT__entry(__array(__u8, intra_quantiser_matrix, 64)
+			 __array(__u8, non_intra_quantiser_matrix, 64)
+			 __array(__u8, chroma_intra_quantiser_matrix, 64)
+			 __array(__u8, chroma_non_intra_quantiser_matrix, 64)),
+	TP_fast_assign(memcpy(__entry->intra_quantiser_matrix, q->intra_quantiser_matrix,
+			      sizeof(__entry->intra_quantiser_matrix));
+		       memcpy(__entry->non_intra_quantiser_matrix, q->non_intra_quantiser_matrix,
+			      sizeof(__entry->non_intra_quantiser_matrix));
+		       memcpy(__entry->chroma_intra_quantiser_matrix,
+			      q->chroma_intra_quantiser_matrix,
+			      sizeof(__entry->chroma_intra_quantiser_matrix));
+		       memcpy(__entry->chroma_non_intra_quantiser_matrix,
+			      q->chroma_non_intra_quantiser_matrix,
+			      sizeof(__entry->chroma_non_intra_quantiser_matrix));),
 	TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
 		  "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
-		  __print_array(__entry->q.intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.intra_quantiser_matrix),
-				sizeof(__entry->q.intra_quantiser_matrix[0])),
-		  __print_array(__entry->q.non_intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.non_intra_quantiser_matrix),
-				sizeof(__entry->q.non_intra_quantiser_matrix[0])),
-		  __print_array(__entry->q.chroma_intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.chroma_intra_quantiser_matrix),
-				sizeof(__entry->q.chroma_intra_quantiser_matrix[0])),
-		  __print_array(__entry->q.chroma_non_intra_quantiser_matrix,
-				ARRAY_SIZE(__entry->q.chroma_non_intra_quantiser_matrix),
-				sizeof(__entry->q.chroma_non_intra_quantiser_matrix[0]))
+		  __print_array(__entry->intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->intra_quantiser_matrix),
+				sizeof(__entry->intra_quantiser_matrix[0])),
+		  __print_array(__entry->non_intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->non_intra_quantiser_matrix),
+				sizeof(__entry->non_intra_quantiser_matrix[0])),
+		  __print_array(__entry->chroma_intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->chroma_intra_quantiser_matrix),
+				sizeof(__entry->chroma_intra_quantiser_matrix[0])),
+		  __print_array(__entry->chroma_non_intra_quantiser_matrix,
+				ARRAY_SIZE(__entry->chroma_non_intra_quantiser_matrix),
+				sizeof(__entry->chroma_non_intra_quantiser_matrix[0]))
 		  )
 )
 
@@ -1227,25 +1903,35 @@ DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
 	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
+	TP_STRUCT__entry(__array(__u8, entropy_coeff_probs, 4 * 8 * 3 * V4L2_VP8_COEFF_PROB_CNT)
+			 __array(__u8, entropy_y_mode_probs, 4)
+			 __array(__u8, entropy_uv_mode_probs, 3)
+			 __array(__u8, entropy_mv_probs, 2 * 19)),
+	TP_fast_assign(memcpy(__entry->entropy_coeff_probs, f->entropy.coeff_probs,
+			      sizeof(__entry->entropy_coeff_probs));
+		       memcpy(__entry->entropy_y_mode_probs, f->entropy.y_mode_probs,
+			      sizeof(__entry->entropy_y_mode_probs));
+		       memcpy(__entry->entropy_uv_mode_probs, f->entropy.uv_mode_probs,
+			      sizeof(__entry->entropy_uv_mode_probs));
+		       memcpy(__entry->entropy_mv_probs, f->entropy.mv_probs,
+			      sizeof(__entry->entropy_mv_probs));),
 	TP_printk("\nentropy.coeff_probs {%s}\n"
 		  "entropy.y_mode_probs %s\n"
 		  "entropy.uv_mode_probs %s\n"
 		  "entropy.mv_probs {%s}",
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->f.entropy.coeff_probs,
-				   sizeof(__entry->f.entropy.coeff_probs),
+				   __entry->entropy_coeff_probs,
+				   sizeof(__entry->entropy_coeff_probs),
 				   false),
-		  __print_array(__entry->f.entropy.y_mode_probs,
-				ARRAY_SIZE(__entry->f.entropy.y_mode_probs),
-				sizeof(__entry->f.entropy.y_mode_probs[0])),
-		  __print_array(__entry->f.entropy.uv_mode_probs,
-				ARRAY_SIZE(__entry->f.entropy.uv_mode_probs),
-				sizeof(__entry->f.entropy.uv_mode_probs[0])),
+		  __print_array(__entry->entropy_y_mode_probs,
+				ARRAY_SIZE(__entry->entropy_y_mode_probs),
+				sizeof(__entry->entropy_y_mode_probs[0])),
+		  __print_array(__entry->entropy_uv_mode_probs,
+				ARRAY_SIZE(__entry->entropy_uv_mode_probs),
+				sizeof(__entry->entropy_uv_mode_probs[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->f.entropy.mv_probs,
-				   sizeof(__entry->f.entropy.mv_probs),
+				   __entry->entropy_mv_probs,
+				   sizeof(__entry->entropy_mv_probs),
 				   false)
 		  )
 )
@@ -1253,8 +1939,82 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
 	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp8_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
+	TP_STRUCT__entry(__array(__s8, segment_quant_update, 4)
+			 __array(__s8, segment_lf_update, 4)
+			 __array(__u8, segment_segment_probs, 3)
+			 __field(__u32, segment_flags)
+			 __array(__s8, lf_ref_frm_delta, 4)
+			 __array(__s8, lf_mb_mode_delta, 4)
+			 __field(__u8, lf_sharpness_level)
+			 __field(__u8, lf_level)
+			 __field(__u32, lf_flags)
+			 __field(__u8, quant_y_ac_qi)
+			 __field(__s8, quant_y_dc_delta)
+			 __field(__s8, quant_y2_dc_delta)
+			 __field(__s8, quant_y2_ac_delta)
+			 __field(__s8, quant_uv_dc_delta)
+			 __field(__s8, quant_uv_ac_delta)
+			 __field(__u8, coder_state_range)
+			 __field(__u8, coder_state_value)
+			 __field(__u8, coder_state_bit_count)
+			 __field(__u16, width)
+			 __field(__u16, height)
+			 __field(__u8, horizontal_scale)
+			 __field(__u8, vertical_scale)
+			 __field(__u8, version)
+			 __field(__u8, prob_skip_false)
+			 __field(__u8, prob_intra)
+			 __field(__u8, prob_last)
+			 __field(__u8, prob_gf)
+			 __field(__u8, num_dct_parts)
+			 __field(__u32, first_part_size)
+			 __field(__u32, first_part_header_bits)
+			 __array(__u32, dct_part_sizes, 8)
+			 __field(__u64, last_frame_ts)
+			 __field(__u64, golden_frame_ts)
+			 __field(__u64, alt_frame_ts)
+			 __field(__u64, flags)),
+	TP_fast_assign(memcpy(__entry->segment_quant_update, f->segment.quant_update,
+			      sizeof(__entry->segment_quant_update));
+		       memcpy(__entry->segment_lf_update, f->segment.lf_update,
+			      sizeof(__entry->segment_lf_update));
+		       memcpy(__entry->segment_segment_probs, f->segment.segment_probs,
+			      sizeof(__entry->segment_segment_probs));
+		       __entry->segment_flags = f->segment.flags;
+		       memcpy(__entry->lf_ref_frm_delta, f->lf.ref_frm_delta,
+			      sizeof(__entry->lf_ref_frm_delta));
+		       memcpy(__entry->lf_mb_mode_delta, f->lf.mb_mode_delta,
+			      sizeof(__entry->lf_mb_mode_delta));
+		       __entry->lf_sharpness_level = f->lf.sharpness_level;
+		       __entry->lf_level = f->lf.level;
+		       __entry->lf_flags = f->lf.flags;
+		       __entry->quant_y_ac_qi = f->quant.y_ac_qi;
+		       __entry->quant_y_dc_delta = f->quant.y_dc_delta;
+		       __entry->quant_y2_dc_delta = f->quant.y2_dc_delta;
+		       __entry->quant_y2_ac_delta = f->quant.y2_ac_delta;
+		       __entry->quant_uv_dc_delta = f->quant.uv_dc_delta;
+		       __entry->quant_uv_ac_delta = f->quant.uv_ac_delta;
+		       __entry->coder_state_range = f->coder_state.range;
+		       __entry->coder_state_value = f->coder_state.value;
+		       __entry->coder_state_bit_count = f->coder_state.bit_count;
+		       __entry->width = f->width;
+		       __entry->height = f->height;
+		       __entry->horizontal_scale = f->horizontal_scale;
+		       __entry->vertical_scale = f->vertical_scale;
+		       __entry->version = f->version;
+		       __entry->prob_skip_false = f->prob_skip_false;
+		       __entry->prob_intra = f->prob_intra;
+		       __entry->prob_last = f->prob_last;
+		       __entry->prob_gf = f->prob_gf;
+		       __entry->num_dct_parts = f->num_dct_parts;
+		       __entry->first_part_size = f->first_part_size;
+		       __entry->first_part_header_bits = f->first_part_header_bits;
+		       memcpy(__entry->dct_part_sizes, f->dct_part_sizes,
+			      sizeof(__entry->dct_part_sizes));
+		       __entry->last_frame_ts = f->last_frame_ts;
+		       __entry->golden_frame_ts = f->golden_frame_ts;
+		       __entry->alt_frame_ts = f->alt_frame_ts;
+		       __entry->flags = f->flags;),
 	TP_printk("\nsegment.quant_update %s\n"
 		  "segment.lf_update %s\n"
 		  "segment.segment_probs %s\n"
@@ -1290,60 +2050,60 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
 		  "golden_frame_ts %llu\n"
 		  "alt_frame_ts %llu\n"
 		  "flags %s",
-		  __print_array(__entry->f.segment.quant_update,
-				ARRAY_SIZE(__entry->f.segment.quant_update),
-				sizeof(__entry->f.segment.quant_update[0])),
-		  __print_array(__entry->f.segment.lf_update,
-				ARRAY_SIZE(__entry->f.segment.lf_update),
-				sizeof(__entry->f.segment.lf_update[0])),
-		  __print_array(__entry->f.segment.segment_probs,
-				ARRAY_SIZE(__entry->f.segment.segment_probs),
-				sizeof(__entry->f.segment.segment_probs[0])),
-		  __print_flags(__entry->f.segment.flags, "|",
+		  __print_array(__entry->segment_quant_update,
+				ARRAY_SIZE(__entry->segment_quant_update),
+				sizeof(__entry->segment_quant_update[0])),
+		  __print_array(__entry->segment_lf_update,
+				ARRAY_SIZE(__entry->segment_lf_update),
+				sizeof(__entry->segment_lf_update[0])),
+		  __print_array(__entry->segment_segment_probs,
+				ARRAY_SIZE(__entry->segment_segment_probs),
+				sizeof(__entry->segment_segment_probs[0])),
+		  __print_flags(__entry->segment_flags, "|",
 		  {V4L2_VP8_SEGMENT_FLAG_ENABLED, "SEGMENT_ENABLED"},
 		  {V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP, "SEGMENT_UPDATE_MAP"},
 		  {V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA, "SEGMENT_UPDATE_FEATURE_DATA"},
 		  {V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE, "SEGMENT_DELTA_VALUE_MODE"}),
-		  __print_array(__entry->f.lf.ref_frm_delta,
-				ARRAY_SIZE(__entry->f.lf.ref_frm_delta),
-				sizeof(__entry->f.lf.ref_frm_delta[0])),
-		  __print_array(__entry->f.lf.mb_mode_delta,
-				ARRAY_SIZE(__entry->f.lf.mb_mode_delta),
-				sizeof(__entry->f.lf.mb_mode_delta[0])),
-		  __entry->f.lf.sharpness_level,
-		  __entry->f.lf.level,
-		  __print_flags(__entry->f.lf.flags, "|",
+		  __print_array(__entry->lf_ref_frm_delta,
+				ARRAY_SIZE(__entry->lf_ref_frm_delta),
+				sizeof(__entry->lf_ref_frm_delta[0])),
+		  __print_array(__entry->lf_mb_mode_delta,
+				ARRAY_SIZE(__entry->lf_mb_mode_delta),
+				sizeof(__entry->lf_mb_mode_delta[0])),
+		  __entry->lf_sharpness_level,
+		  __entry->lf_level,
+		  __print_flags(__entry->lf_flags, "|",
 		  {V4L2_VP8_LF_ADJ_ENABLE, "LF_ADJ_ENABLED"},
 		  {V4L2_VP8_LF_DELTA_UPDATE, "LF_DELTA_UPDATE"},
 		  {V4L2_VP8_LF_FILTER_TYPE_SIMPLE, "LF_FILTER_TYPE_SIMPLE"}),
-		  __entry->f.quant.y_ac_qi,
-		  __entry->f.quant.y_dc_delta,
-		  __entry->f.quant.y2_dc_delta,
-		  __entry->f.quant.y2_ac_delta,
-		  __entry->f.quant.uv_dc_delta,
-		  __entry->f.quant.uv_ac_delta,
-		  __entry->f.coder_state.range,
-		  __entry->f.coder_state.value,
-		  __entry->f.coder_state.bit_count,
-		  __entry->f.width,
-		  __entry->f.height,
-		  __entry->f.horizontal_scale,
-		  __entry->f.vertical_scale,
-		  __entry->f.version,
-		  __entry->f.prob_skip_false,
-		  __entry->f.prob_intra,
-		  __entry->f.prob_last,
-		  __entry->f.prob_gf,
-		  __entry->f.num_dct_parts,
-		  __entry->f.first_part_size,
-		  __entry->f.first_part_header_bits,
-		  __print_array(__entry->f.dct_part_sizes,
-				ARRAY_SIZE(__entry->f.dct_part_sizes),
-				sizeof(__entry->f.dct_part_sizes[0])),
-		  __entry->f.last_frame_ts,
-		  __entry->f.golden_frame_ts,
-		  __entry->f.alt_frame_ts,
-		  __print_flags(__entry->f.flags, "|",
+		  __entry->quant_y_ac_qi,
+		  __entry->quant_y_dc_delta,
+		  __entry->quant_y2_dc_delta,
+		  __entry->quant_y2_ac_delta,
+		  __entry->quant_uv_dc_delta,
+		  __entry->quant_uv_ac_delta,
+		  __entry->coder_state_range,
+		  __entry->coder_state_value,
+		  __entry->coder_state_bit_count,
+		  __entry->width,
+		  __entry->height,
+		  __entry->horizontal_scale,
+		  __entry->vertical_scale,
+		  __entry->version,
+		  __entry->prob_skip_false,
+		  __entry->prob_intra,
+		  __entry->prob_last,
+		  __entry->prob_gf,
+		  __entry->num_dct_parts,
+		  __entry->first_part_size,
+		  __entry->first_part_header_bits,
+		  __print_array(__entry->dct_part_sizes,
+				ARRAY_SIZE(__entry->dct_part_sizes),
+				sizeof(__entry->dct_part_sizes[0])),
+		  __entry->last_frame_ts,
+		  __entry->golden_frame_ts,
+		  __entry->alt_frame_ts,
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_VP8_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
 		  {V4L2_VP8_FRAME_FLAG_EXPERIMENTAL, "EXPERIMENTAL"},
 		  {V4L2_VP8_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
@@ -1368,8 +2128,78 @@ DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
 	TP_ARGS(f),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_frame, f)),
-	TP_fast_assign(__entry->f = *f;),
+	TP_STRUCT__entry(__array(__s8, lf_ref_deltas, 4)
+			 __array(__s8, lf_mode_deltas, 2)
+			 __field(__u8, lf_level)
+			 __field(__u8, lf_sharpness)
+			 __field(__u8, lf_flags)
+			 __field(__u8, quant_base_q_idx)
+			 __field(__s8, quant_delta_q_y_dc)
+			 __field(__s8, quant_delta_q_uv_dc)
+			 __field(__s8, quant_delta_q_uv_ac)
+			 __array(__u8, seg_feature_data, sizeof(__s16) * 8 * 4)
+			 __array(__u8, seg_feature_enabled, 8)
+			 __array(__u8, seg_tree_probs, 7)
+			 __array(__u8, seg_pred_probs, 3)
+			 __field(__u8, seg_flags)
+			 __field(__u32, flags)
+			 __field(__u16, compressed_header_size)
+			 __field(__u16, uncompressed_header_size)
+			 __field(__u16, frame_width_minus_1)
+			 __field(__u16, frame_height_minus_1)
+			 __field(__u16, render_width_minus_1)
+			 __field(__u16, render_height_minus_1)
+			 __field(__u64, last_frame_ts)
+			 __field(__u64, golden_frame_ts)
+			 __field(__u64, alt_frame_ts)
+			 __field(__u8, ref_frame_sign_bias)
+			 __field(__u8, reset_frame_context)
+			 __field(__u8, frame_context_idx)
+			 __field(__u8, profile)
+			 __field(__u8, bit_depth)
+			 __field(__u8, interpolation_filter)
+			 __field(__u8, tile_cols_log2)
+			 __field(__u8, tile_rows_log2)
+			 __field(__u8, reference_mode)),
+	TP_fast_assign(memcpy(__entry->lf_ref_deltas, f->lf.ref_deltas,
+			      sizeof(__entry->lf_ref_deltas));
+		       memcpy(__entry->lf_mode_deltas, f->lf.mode_deltas,
+			      sizeof(__entry->lf_mode_deltas));
+		       __entry->lf_level = f->lf.level;
+		       __entry->lf_sharpness = f->lf.sharpness;
+		       __entry->lf_flags = f->lf.flags;
+		       __entry->quant_base_q_idx = f->quant.base_q_idx;
+		       __entry->quant_delta_q_y_dc = f->quant.delta_q_y_dc;
+		       __entry->quant_delta_q_uv_dc = f->quant.delta_q_uv_dc;
+		       __entry->quant_delta_q_uv_ac = f->quant.delta_q_uv_ac;
+		       memcpy(__entry->seg_feature_data, f->seg.feature_data,
+			      sizeof(__entry->seg_feature_data));
+		       memcpy(__entry->seg_feature_enabled, f->seg.feature_enabled,
+			      sizeof(__entry->seg_feature_enabled));
+		       memcpy(__entry->seg_tree_probs, f->seg.tree_probs,
+			      sizeof(__entry->seg_tree_probs));
+		       memcpy(__entry->seg_pred_probs, f->seg.pred_probs,
+			      sizeof(__entry->seg_pred_probs));
+		       __entry->seg_flags = f->seg.flags;
+		       __entry->flags = f->flags;
+		       __entry->compressed_header_size = f->compressed_header_size;
+		       __entry->uncompressed_header_size = f->uncompressed_header_size;
+		       __entry->frame_width_minus_1 = f->frame_width_minus_1;
+		       __entry->frame_height_minus_1 = f->frame_height_minus_1;
+		       __entry->render_width_minus_1 = f->render_width_minus_1;
+		       __entry->render_height_minus_1 = f->render_height_minus_1;
+		       __entry->last_frame_ts = f->last_frame_ts;
+		       __entry->golden_frame_ts = f->golden_frame_ts;
+		       __entry->alt_frame_ts = f->alt_frame_ts;
+		       __entry->ref_frame_sign_bias = f->ref_frame_sign_bias;
+		       __entry->reset_frame_context = f->reset_frame_context;
+		       __entry->frame_context_idx = f->frame_context_idx;
+		       __entry->profile = f->profile;
+		       __entry->bit_depth = f->bit_depth;
+		       __entry->interpolation_filter = f->interpolation_filter;
+		       __entry->tile_cols_log2 = f->tile_cols_log2;
+		       __entry->tile_rows_log2 = f->tile_rows_log2;
+		       __entry->reference_mode = f->reference_mode;),
 	TP_printk("\nlf.ref_deltas %s\n"
 		  "lf.mode_deltas %s\n"
 		  "lf.level %u\n"
@@ -1403,41 +2233,41 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 		  "tile_cols_log2 %u\n"
 		  "tile_rows_log_2 %u\n"
 		  "reference_mode %s\n",
-		  __print_array(__entry->f.lf.ref_deltas,
-				ARRAY_SIZE(__entry->f.lf.ref_deltas),
-				sizeof(__entry->f.lf.ref_deltas[0])),
-		  __print_array(__entry->f.lf.mode_deltas,
-				ARRAY_SIZE(__entry->f.lf.mode_deltas),
-				sizeof(__entry->f.lf.mode_deltas[0])),
-		  __entry->f.lf.level,
-		  __entry->f.lf.sharpness,
-		  __print_flags(__entry->f.lf.flags, "|",
+		  __print_array(__entry->lf_ref_deltas,
+				ARRAY_SIZE(__entry->lf_ref_deltas),
+				sizeof(__entry->lf_ref_deltas[0])),
+		  __print_array(__entry->lf_mode_deltas,
+				ARRAY_SIZE(__entry->lf_mode_deltas),
+				sizeof(__entry->lf_mode_deltas[0])),
+		  __entry->lf_level,
+		  __entry->lf_sharpness,
+		  __print_flags(__entry->lf_flags, "|",
 		  {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED, "DELTA_ENABLED"},
 		  {V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE, "DELTA_UPDATE"}),
-		  __entry->f.quant.base_q_idx,
-		  __entry->f.quant.delta_q_y_dc,
-		  __entry->f.quant.delta_q_uv_dc,
-		  __entry->f.quant.delta_q_uv_ac,
+		  __entry->quant_base_q_idx,
+		  __entry->quant_delta_q_y_dc,
+		  __entry->quant_delta_q_uv_dc,
+		  __entry->quant_delta_q_uv_ac,
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->f.seg.feature_data,
-				   sizeof(__entry->f.seg.feature_data),
+				   __entry->seg_feature_data,
+				   sizeof(__entry->seg_feature_data),
 				   false),
-		  __print_array(__entry->f.seg.feature_enabled,
-				ARRAY_SIZE(__entry->f.seg.feature_enabled),
-				sizeof(__entry->f.seg.feature_enabled[0])),
-		  __print_array(__entry->f.seg.tree_probs,
-				ARRAY_SIZE(__entry->f.seg.tree_probs),
-				sizeof(__entry->f.seg.tree_probs[0])),
-		  __print_array(__entry->f.seg.pred_probs,
-				ARRAY_SIZE(__entry->f.seg.pred_probs),
-				sizeof(__entry->f.seg.pred_probs[0])),
-		  __print_flags(__entry->f.seg.flags, "|",
+		  __print_array(__entry->seg_feature_enabled,
+				ARRAY_SIZE(__entry->seg_feature_enabled),
+				sizeof(__entry->seg_feature_enabled[0])),
+		  __print_array(__entry->seg_tree_probs,
+				ARRAY_SIZE(__entry->seg_tree_probs),
+				sizeof(__entry->seg_tree_probs[0])),
+		  __print_array(__entry->seg_pred_probs,
+				ARRAY_SIZE(__entry->seg_pred_probs),
+				sizeof(__entry->seg_pred_probs[0])),
+		  __print_flags(__entry->seg_flags, "|",
 		  {V4L2_VP9_SEGMENTATION_FLAG_ENABLED, "ENABLED"},
 		  {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP, "UPDATE_MAP"},
 		  {V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE, "TEMPORAL_UPDATE"},
 		  {V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA, "UPDATE_DATA"},
 		  {V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE, "ABS_OR_DELTA_UPDATE"}),
-		  __print_flags(__entry->f.flags, "|",
+		  __print_flags(__entry->flags, "|",
 		  {V4L2_VP9_FRAME_FLAG_KEY_FRAME, "KEY_FRAME"},
 		  {V4L2_VP9_FRAME_FLAG_SHOW_FRAME, "SHOW_FRAME"},
 		  {V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT, "ERROR_RESILIENT"},
@@ -1448,35 +2278,35 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 		  {V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING, "X_SUBSAMPLING"},
 		  {V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING, "Y_SUBSAMPLING"},
 		  {V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING, "COLOR_RANGE_FULL_SWING"}),
-		  __entry->f.compressed_header_size,
-		  __entry->f.uncompressed_header_size,
-		  __entry->f.frame_width_minus_1,
-		  __entry->f.frame_height_minus_1,
-		  __entry->f.render_width_minus_1,
-		  __entry->f.render_height_minus_1,
-		  __entry->f.last_frame_ts,
-		  __entry->f.golden_frame_ts,
-		  __entry->f.alt_frame_ts,
-		  __print_symbolic(__entry->f.ref_frame_sign_bias,
+		  __entry->compressed_header_size,
+		  __entry->uncompressed_header_size,
+		  __entry->frame_width_minus_1,
+		  __entry->frame_height_minus_1,
+		  __entry->render_width_minus_1,
+		  __entry->render_height_minus_1,
+		  __entry->last_frame_ts,
+		  __entry->golden_frame_ts,
+		  __entry->alt_frame_ts,
+		  __print_symbolic(__entry->ref_frame_sign_bias,
 		  {V4L2_VP9_SIGN_BIAS_LAST, "SIGN_BIAS_LAST"},
 		  {V4L2_VP9_SIGN_BIAS_GOLDEN, "SIGN_BIAS_GOLDEN"},
 		  {V4L2_VP9_SIGN_BIAS_ALT, "SIGN_BIAS_ALT"}),
-		  __print_symbolic(__entry->f.reset_frame_context,
+		  __print_symbolic(__entry->reset_frame_context,
 		  {V4L2_VP9_RESET_FRAME_CTX_NONE, "RESET_FRAME_CTX_NONE"},
 		  {V4L2_VP9_RESET_FRAME_CTX_SPEC, "RESET_FRAME_CTX_SPEC"},
 		  {V4L2_VP9_RESET_FRAME_CTX_ALL, "RESET_FRAME_CTX_ALL"}),
-		  __entry->f.frame_context_idx,
-		  __entry->f.profile,
-		  __entry->f.bit_depth,
-		  __print_symbolic(__entry->f.interpolation_filter,
+		  __entry->frame_context_idx,
+		  __entry->profile,
+		  __entry->bit_depth,
+		  __print_symbolic(__entry->interpolation_filter,
 		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP, "INTERP_FILTER_EIGHTTAP"},
 		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTH, "INTERP_FILTER_EIGHTTAP_SMOOTH"},
 		  {V4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARP, "INTERP_FILTER_EIGHTTAP_SHARP"},
 		  {V4L2_VP9_INTERP_FILTER_BILINEAR, "INTERP_FILTER_BILINEAR"},
 		  {V4L2_VP9_INTERP_FILTER_SWITCHABLE, "INTERP_FILTER_SWITCHABLE"}),
-		  __entry->f.tile_cols_log2,
-		  __entry->f.tile_rows_log2,
-		  __print_symbolic(__entry->f.reference_mode,
+		  __entry->tile_cols_log2,
+		  __entry->tile_rows_log2,
+		  __print_symbolic(__entry->reference_mode,
 		  {V4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCE, "REFERENCE_MODE_SINGLE_REFERENCE"},
 		  {V4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCE, "REFERENCE_MODE_COMPOUND_REFERENCE"},
 		  {V4L2_VP9_REFERENCE_MODE_SELECT, "REFERENCE_MODE_SELECT"}))
@@ -1485,8 +2315,35 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
 	TP_ARGS(h),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
-	TP_fast_assign(__entry->h = *h;),
+	TP_STRUCT__entry(__field(__u8, tx_mode)
+			 __array(__u8, tx8, 2 * 1)
+			 __array(__u8, tx16, 2 * 2)
+			 __array(__u8, tx32, 2 * 3)
+			 __array(__u8, skip, 3)
+			 __array(__u8, inter_mode, 7 * 3)
+			 __array(__u8, interp_filter, 4 * 2)
+			 __array(__u8, is_inter, 4)
+			 __array(__u8, comp_mode, 5)
+			 __array(__u8, single_ref, 5 * 2)
+			 __array(__u8, comp_ref, 5)
+			 __array(__u8, y_mode, 4 * 9)
+			 __array(__u8, uv_mode, 10 * 9)
+			 __array(__u8, partition, 16 * 3)),
+	TP_fast_assign(__entry->tx_mode = h->tx_mode;
+		       memcpy(__entry->tx8, h->tx8, sizeof(__entry->tx8));
+		       memcpy(__entry->tx16, h->tx16, sizeof(__entry->tx16));
+		       memcpy(__entry->tx32, h->tx32, sizeof(__entry->tx32));
+		       memcpy(__entry->skip, h->skip, sizeof(__entry->skip));
+		       memcpy(__entry->inter_mode, h->inter_mode, sizeof(__entry->inter_mode));
+		       memcpy(__entry->interp_filter, h->interp_filter,
+			      sizeof(__entry->interp_filter));
+		       memcpy(__entry->is_inter, h->is_inter, sizeof(__entry->is_inter));
+		       memcpy(__entry->comp_mode, h->comp_mode, sizeof(__entry->comp_mode));
+		       memcpy(__entry->single_ref, h->single_ref, sizeof(__entry->single_ref));
+		       memcpy(__entry->comp_ref, h->comp_ref, sizeof(__entry->comp_ref));
+		       memcpy(__entry->y_mode, h->y_mode, sizeof(__entry->y_mode));
+		       memcpy(__entry->uv_mode, h->uv_mode, sizeof(__entry->uv_mode));
+		       memcpy(__entry->partition, h->partition, sizeof(__entry->partition));),
 	TP_printk("\ntx_mode %s\n"
 		  "tx8 {%s}\n"
 		  "tx16 {%s}\n"
@@ -1501,59 +2358,59 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 		  "y_mode {%s}\n"
 		  "uv_mode {%s}\n"
 		  "partition {%s}\n",
-		  __print_symbolic(__entry->h.tx_mode,
+		  __print_symbolic(__entry->tx_mode,
 		  {V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
 		  {V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
 		  {V4L2_VP9_TX_MODE_ALLOW_16X16, "TX_MODE_ALLOW_16X16"},
 		  {V4L2_VP9_TX_MODE_ALLOW_32X32, "TX_MODE_ALLOW_32X32"},
 		  {V4L2_VP9_TX_MODE_SELECT, "TX_MODE_SELECT"}),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.tx8,
-				   sizeof(__entry->h.tx8),
+				   __entry->tx8,
+				   sizeof(__entry->tx8),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.tx16,
-				   sizeof(__entry->h.tx16),
+				   __entry->tx16,
+				   sizeof(__entry->tx16),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.tx32,
-				   sizeof(__entry->h.tx32),
+				   __entry->tx32,
+				   sizeof(__entry->tx32),
 				   false),
-		  __print_array(__entry->h.skip,
-				ARRAY_SIZE(__entry->h.skip),
-				sizeof(__entry->h.skip[0])),
+		  __print_array(__entry->skip,
+				ARRAY_SIZE(__entry->skip),
+				sizeof(__entry->skip[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.inter_mode,
-				   sizeof(__entry->h.inter_mode),
+				   __entry->inter_mode,
+				   sizeof(__entry->inter_mode),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.interp_filter,
-				   sizeof(__entry->h.interp_filter),
+				   __entry->interp_filter,
+				   sizeof(__entry->interp_filter),
 				   false),
-		  __print_array(__entry->h.is_inter,
-				ARRAY_SIZE(__entry->h.is_inter),
-				sizeof(__entry->h.is_inter[0])),
-		  __print_array(__entry->h.comp_mode,
-				ARRAY_SIZE(__entry->h.comp_mode),
-				sizeof(__entry->h.comp_mode[0])),
+		  __print_array(__entry->is_inter,
+				ARRAY_SIZE(__entry->is_inter),
+				sizeof(__entry->is_inter[0])),
+		  __print_array(__entry->comp_mode,
+				ARRAY_SIZE(__entry->comp_mode),
+				sizeof(__entry->comp_mode[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.single_ref,
-				   sizeof(__entry->h.single_ref),
+				   __entry->single_ref,
+				   sizeof(__entry->single_ref),
 				   false),
-		  __print_array(__entry->h.comp_ref,
-				ARRAY_SIZE(__entry->h.comp_ref),
-				sizeof(__entry->h.comp_ref[0])),
+		  __print_array(__entry->comp_ref,
+				ARRAY_SIZE(__entry->comp_ref),
+				sizeof(__entry->comp_ref[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.y_mode,
-				   sizeof(__entry->h.y_mode),
+				   __entry->y_mode,
+				   sizeof(__entry->y_mode),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.uv_mode,
-				   sizeof(__entry->h.uv_mode),
+				   __entry->uv_mode,
+				   sizeof(__entry->uv_mode),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.partition,
-				   sizeof(__entry->h.partition),
+				   __entry->partition,
+				   sizeof(__entry->partition),
 				   false)
 	)
 );
@@ -1561,12 +2418,12 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
 	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
 	TP_ARGS(h),
-	TP_STRUCT__entry(__field_struct(struct v4l2_ctrl_vp9_compressed_hdr, h)),
-	TP_fast_assign(__entry->h = *h;),
+	TP_STRUCT__entry(__array(__u8, coef, 4 * 2 * 2 * 6 * 6 * 3)),
+	TP_fast_assign(memcpy(__entry->coef, h->coef, sizeof(__entry->coef));),
 	TP_printk("\n coef {%s}",
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->h.coef,
-				   sizeof(__entry->h.coef),
+				   __entry->coef,
+				   sizeof(__entry->coef),
 				   false)
 	)
 );
@@ -1574,8 +2431,24 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
 DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
 	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
 	TP_ARGS(p),
-	TP_STRUCT__entry(__field_struct(struct v4l2_vp9_mv_probs, p)),
-	TP_fast_assign(__entry->p = *p;),
+	TP_STRUCT__entry(__array(__u8, joint, 3)
+			 __array(__u8, sign, 2)
+			 __array(__u8, classes, 2 * 10)
+			 __array(__u8, class0_bit, 2)
+			 __array(__u8, bits, 2 * 10)
+			 __array(__u8, class0_fr, 2 * 2 * 3)
+			 __array(__u8, fr, 2 * 3)
+			 __array(__u8, class0_hp, 2)
+			 __array(__u8, hp, 2)),
+	TP_fast_assign(memcpy(__entry->joint, p->joint, sizeof(__entry->joint));
+		       memcpy(__entry->sign, p->sign, sizeof(__entry->sign));
+		       memcpy(__entry->classes, p->classes, sizeof(__entry->classes));
+		       memcpy(__entry->class0_bit, p->class0_bit, sizeof(__entry->class0_bit));
+		       memcpy(__entry->bits, p->bits, sizeof(__entry->bits));
+		       memcpy(__entry->class0_fr, p->class0_fr, sizeof(__entry->class0_fr));
+		       memcpy(__entry->fr, p->fr, sizeof(__entry->fr));
+		       memcpy(__entry->class0_hp, p->class0_hp, sizeof(__entry->class0_hp));
+		       memcpy(__entry->hp, p->hp, sizeof(__entry->hp));),
 	TP_printk("\n joint %s\n"
 		  "sign %s\n"
 		  "classes {%s}\n"
@@ -1585,37 +2458,37 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
 		  "fr {%s}\n"
 		  "class0_hp %s\n"
 		  "hp %s\n",
-		  __print_array(__entry->p.joint,
-				ARRAY_SIZE(__entry->p.joint),
-				sizeof(__entry->p.joint[0])),
-		  __print_array(__entry->p.sign,
-				ARRAY_SIZE(__entry->p.sign),
-				sizeof(__entry->p.sign[0])),
+		  __print_array(__entry->joint,
+				ARRAY_SIZE(__entry->joint),
+				sizeof(__entry->joint[0])),
+		  __print_array(__entry->sign,
+				ARRAY_SIZE(__entry->sign),
+				sizeof(__entry->sign[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.classes,
-				   sizeof(__entry->p.classes),
+				   __entry->classes,
+				   sizeof(__entry->classes),
 				   false),
-		  __print_array(__entry->p.class0_bit,
-				ARRAY_SIZE(__entry->p.class0_bit),
-				sizeof(__entry->p.class0_bit[0])),
+		  __print_array(__entry->class0_bit,
+				ARRAY_SIZE(__entry->class0_bit),
+				sizeof(__entry->class0_bit[0])),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.bits,
-				   sizeof(__entry->p.bits),
+				   __entry->bits,
+				   sizeof(__entry->bits),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.class0_fr,
-				   sizeof(__entry->p.class0_fr),
+				   __entry->class0_fr,
+				   sizeof(__entry->class0_fr),
 				   false),
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
-				   __entry->p.fr,
-				   sizeof(__entry->p.fr),
+				   __entry->fr,
+				   sizeof(__entry->fr),
 				   false),
-		  __print_array(__entry->p.class0_hp,
-				ARRAY_SIZE(__entry->p.class0_hp),
-				sizeof(__entry->p.class0_hp[0])),
-		  __print_array(__entry->p.hp,
-				ARRAY_SIZE(__entry->p.hp),
-				sizeof(__entry->p.hp[0]))
+		  __print_array(__entry->class0_hp,
+				ARRAY_SIZE(__entry->class0_hp),
+				sizeof(__entry->class0_hp[0])),
+		  __print_array(__entry->hp,
+				ARRAY_SIZE(__entry->hp),
+				sizeof(__entry->hp[0]))
 	)
 );
 

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 3/9] media: Add tgid and fd fields in v4l2_fh struct
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 1/9] media: Move visl traces to v4l2-core Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 2/9] media: Map each struct field to its own trace field Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 4/9] media: Add tgid and fd to the v4l2-requests trace fields Detlev Casanova
                   ` (6 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

These fields will be used in traces to help userspace tracing tools
identify streams.

The tgid field will keep the PID of the process that opened the video
file.
That is needed because trace calls can happen in IRQs, for which there is
no current PID.

The fd field helps identify the context in case the same process opens the
video device multiple times.
Note that the fd field is set in the __video_do_ioctl() function.
That is because the file descriptor has not been allocated yet when
v4l2_open() is called.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
Reviewed-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>
---
 drivers/media/v4l2-core/v4l2-fh.c    |  1 +
 drivers/media/v4l2-core/v4l2-ioctl.c | 17 +++++++++++++++++
 include/media/v4l2-fh.h              |  4 ++++
 3 files changed, 22 insertions(+)

diff --git a/drivers/media/v4l2-core/v4l2-fh.c b/drivers/media/v4l2-core/v4l2-fh.c
index b184bed8aca9..9c2ddd1c2137 100644
--- a/drivers/media/v4l2-core/v4l2-fh.c
+++ b/drivers/media/v4l2-core/v4l2-fh.c
@@ -37,6 +37,7 @@ void v4l2_fh_init(struct v4l2_fh *fh, struct video_device *vdev)
 	INIT_LIST_HEAD(&fh->available);
 	INIT_LIST_HEAD(&fh->subscribed);
 	fh->sequence = -1;
+	fh->tgid = current->tgid;
 	mutex_init(&fh->subscribe_lock);
 }
 EXPORT_SYMBOL_GPL(v4l2_fh_init);
diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index a2b650f4ec3c..c8746a1637f5 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/compat.h>
+#include <linux/fdtable.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -3061,6 +3062,16 @@ void v4l_printk_ioctl(const char *prefix, unsigned int cmd)
 }
 EXPORT_SYMBOL(v4l_printk_ioctl);
 
+static int _file_iterate(const void *priv, struct file *filp, unsigned int fd)
+{
+	const struct file *fh_filp = priv;
+
+	if (fh_filp == filp)
+		return fd;
+
+	return 0;
+}
+
 static long __video_do_ioctl(struct file *file,
 		unsigned int cmd, void *arg)
 {
@@ -3081,6 +3092,12 @@ static long __video_do_ioctl(struct file *file,
 		return ret;
 	}
 
+	if (unlikely(!vfh->fd)) {
+		vfh->fd = iterate_fd(current->files, 0, _file_iterate, file);
+		if (!vfh->fd)
+			vfh->fd = -1;
+	}
+
 	/*
 	 * We need to serialize streamon/off/reqbufs with queueing new requests.
 	 * These ioctls may trigger the cancellation of a streaming
diff --git a/include/media/v4l2-fh.h b/include/media/v4l2-fh.h
index aad4b3689d7e..4ef4e58ab8d1 100644
--- a/include/media/v4l2-fh.h
+++ b/include/media/v4l2-fh.h
@@ -28,6 +28,8 @@ struct v4l2_ctrl_handler;
  * @vdev: pointer to &struct video_device
  * @ctrl_handler: pointer to &struct v4l2_ctrl_handler
  * @prio: priority of the file handler, as defined by &enum v4l2_priority
+ * @tgid: process id that initialized the v4l2_fh
+ * @fd: file descriptor associated to this v4l2_fh for the process id in tgid
  *
  * @wait: event' s wait queue
  * @subscribe_lock: serialise changes to the subscribed list; guarantee that
@@ -44,6 +46,8 @@ struct v4l2_fh {
 	struct video_device	*vdev;
 	struct v4l2_ctrl_handler *ctrl_handler;
 	enum v4l2_priority	prio;
+	uint32_t		tgid;
+	int			fd;
 
 	/* Events */
 	wait_queue_head_t	wait;

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 4/9] media: Add tgid and fd to the v4l2-requests trace fields
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (2 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 3/9] media: Add tgid and fd fields in v4l2_fh struct Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 5/9] media: Add missing types to v4l2_ctrl_ptr Detlev Casanova
                   ` (5 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

With these fields, userspace can better track which trace event matches
with a given stream.

Even though the trace shows the PID (based on current->tgid), trace
functions could be called from other contexts, therefore showing the wrong
PID, or none at all.

These will ensure that the trace event can be matched with the PID/FD that
opened and configured the video device file.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
Reviewed-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>
---
 drivers/media/test-drivers/visl/visl-dec.c |  68 ++--
 include/trace/events/v4l2_controls.h       | 628 +++++++++++++++++++----------
 2 files changed, 445 insertions(+), 251 deletions(-)

diff --git a/drivers/media/test-drivers/visl/visl-dec.c b/drivers/media/test-drivers/visl/visl-dec.c
index 1c66a1b8d78f..2a065a6249ad 100644
--- a/drivers/media/test-drivers/visl/visl-dec.c
+++ b/drivers/media/test-drivers/visl/visl-dec.c
@@ -489,67 +489,71 @@ static void visl_tpg_fill(struct visl_ctx *ctx, struct visl_run *run)
 static void visl_trace_ctrls(struct visl_ctx *ctx, struct visl_run *run)
 {
 	int i;
+	struct v4l2_fh *fh = &ctx->fh;
 
 	switch (ctx->current_codec) {
 	default:
 	case VISL_CODEC_NONE:
 		break;
 	case VISL_CODEC_FWHT:
-		trace_v4l2_ctrl_fwht_params(run->fwht.params);
+		trace_v4l2_ctrl_fwht_params(fh->tgid, fh->fd, run->fwht.params);
 		break;
 	case VISL_CODEC_MPEG2:
-		trace_v4l2_ctrl_mpeg2_sequence(run->mpeg2.seq);
-		trace_v4l2_ctrl_mpeg2_picture(run->mpeg2.pic);
-		trace_v4l2_ctrl_mpeg2_quantisation(run->mpeg2.quant);
+		trace_v4l2_ctrl_mpeg2_sequence(fh->tgid, fh->fd, run->mpeg2.seq);
+		trace_v4l2_ctrl_mpeg2_picture(fh->tgid, fh->fd, run->mpeg2.pic);
+		trace_v4l2_ctrl_mpeg2_quantisation(fh->tgid, fh->fd, run->mpeg2.quant);
 		break;
 	case VISL_CODEC_VP8:
-		trace_v4l2_ctrl_vp8_frame(run->vp8.frame);
-		trace_v4l2_ctrl_vp8_entropy(run->vp8.frame);
+		trace_v4l2_ctrl_vp8_frame(fh->tgid, fh->fd, run->vp8.frame);
+		trace_v4l2_ctrl_vp8_entropy(fh->tgid, fh->fd, run->vp8.frame);
 		break;
 	case VISL_CODEC_VP9:
-		trace_v4l2_ctrl_vp9_frame(run->vp9.frame);
-		trace_v4l2_ctrl_vp9_compressed_hdr(run->vp9.probs);
-		trace_v4l2_ctrl_vp9_compressed_coeff(run->vp9.probs);
-		trace_v4l2_vp9_mv_probs(&run->vp9.probs->mv);
+		trace_v4l2_ctrl_vp9_frame(fh->tgid, fh->fd, run->vp9.frame);
+		trace_v4l2_ctrl_vp9_compressed_hdr(fh->tgid, fh->fd, run->vp9.probs);
+		trace_v4l2_ctrl_vp9_compressed_coeff(fh->tgid, fh->fd, run->vp9.probs);
+		trace_v4l2_vp9_mv_probs(fh->tgid, fh->fd, &run->vp9.probs->mv);
 		break;
 	case VISL_CODEC_H264:
-		trace_v4l2_ctrl_h264_sps(run->h264.sps);
-		trace_v4l2_ctrl_h264_pps(run->h264.pps);
-		trace_v4l2_ctrl_h264_scaling_matrix(run->h264.sm);
-		trace_v4l2_ctrl_h264_slice_params(run->h264.spram);
+		trace_v4l2_ctrl_h264_sps(fh->tgid, fh->fd, run->h264.sps);
+		trace_v4l2_ctrl_h264_pps(fh->tgid, fh->fd, run->h264.pps);
+		trace_v4l2_ctrl_h264_scaling_matrix(fh->tgid, fh->fd, run->h264.sm);
+		trace_v4l2_ctrl_h264_slice_params(fh->tgid, fh->fd, run->h264.spram);
 
 		for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
-			trace_v4l2_h264_ref_pic_list0(&run->h264.spram->ref_pic_list0[i], i);
+			trace_v4l2_h264_ref_pic_list0(fh->tgid, fh->fd,
+						      &run->h264.spram->ref_pic_list0[i], i);
 		for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
-			trace_v4l2_h264_ref_pic_list1(&run->h264.spram->ref_pic_list1[i], i);
+			trace_v4l2_h264_ref_pic_list1(fh->tgid, fh->fd,
+						      &run->h264.spram->ref_pic_list1[i], i);
 
-		trace_v4l2_ctrl_h264_decode_params(run->h264.dpram);
+		trace_v4l2_ctrl_h264_decode_params(fh->tgid, fh->fd, run->h264.dpram);
 
 		for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++)
-			trace_v4l2_h264_dpb_entry(&run->h264.dpram->dpb[i], i);
+			trace_v4l2_h264_dpb_entry(fh->tgid, fh->fd, &run->h264.dpram->dpb[i], i);
 
-		trace_v4l2_ctrl_h264_pred_weights(run->h264.pwht);
+		trace_v4l2_ctrl_h264_pred_weights(fh->tgid, fh->fd, run->h264.pwht);
 		break;
 	case VISL_CODEC_HEVC:
-		trace_v4l2_ctrl_hevc_sps(run->hevc.sps);
-		trace_v4l2_ctrl_hevc_pps(run->hevc.pps);
-		trace_v4l2_ctrl_hevc_slice_params(run->hevc.spram);
-		trace_v4l2_ctrl_hevc_scaling_matrix(run->hevc.sm);
-		trace_v4l2_ctrl_hevc_decode_params(run->hevc.dpram);
+		trace_v4l2_ctrl_hevc_sps(fh->tgid, fh->fd, run->hevc.sps);
+		trace_v4l2_ctrl_hevc_pps(fh->tgid, fh->fd, run->hevc.pps);
+		trace_v4l2_ctrl_hevc_slice_params(fh->tgid, fh->fd, run->hevc.spram);
+		trace_v4l2_ctrl_hevc_scaling_matrix(fh->tgid, fh->fd, run->hevc.sm);
+		trace_v4l2_ctrl_hevc_decode_params(fh->tgid, fh->fd, run->hevc.dpram);
 
 		for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++)
-			trace_v4l2_hevc_dpb_entry(&run->hevc.dpram->dpb[i]);
+			trace_v4l2_hevc_dpb_entry(fh->tgid, fh->fd, &run->hevc.dpram->dpb[i]);
 
-		trace_v4l2_hevc_pred_weight_table(&run->hevc.spram->pred_weight_table);
-		trace_v4l2_ctrl_hevc_ext_sps_lt_rps(run->hevc.rps_lt);
-		trace_v4l2_ctrl_hevc_ext_sps_st_rps(run->hevc.rps_st);
 
+		trace_v4l2_hevc_pred_weight_table(fh->tgid, fh->fd,
+						  &run->hevc.spram->pred_weight_table);
+		trace_v4l2_ctrl_hevc_ext_sps_lt_rps(fh->tgid, fh->fd, run->hevc.rps_lt);
+		trace_v4l2_ctrl_hevc_ext_sps_st_rps(fh->tgid, fh->fd, run->hevc.rps_st);
 		break;
 	case VISL_CODEC_AV1:
-		trace_v4l2_ctrl_av1_sequence(run->av1.seq);
-		trace_v4l2_ctrl_av1_frame(run->av1.frame);
-		trace_v4l2_ctrl_av1_film_grain(run->av1.grain);
-		trace_v4l2_ctrl_av1_tile_group_entry(run->av1.tge);
+		trace_v4l2_ctrl_av1_sequence(fh->tgid, fh->fd, run->av1.seq);
+		trace_v4l2_ctrl_av1_frame(fh->tgid, fh->fd, run->av1.frame);
+		trace_v4l2_ctrl_av1_film_grain(fh->tgid, fh->fd, run->av1.grain);
+		trace_v4l2_ctrl_av1_tile_group_entry(fh->tgid, fh->fd, run->av1.tge);
 		break;
 	}
 }
diff --git a/include/trace/events/v4l2_controls.h b/include/trace/events/v4l2_controls.h
index 3a9bc75752bf..a7c61c36a025 100644
--- a/include/trace/events/v4l2_controls.h
+++ b/include/trace/events/v4l2_controls.h
@@ -14,27 +14,39 @@
  * They can be identified by the name of the event. All control fields are copied in a TP_STRUCT
  * field so that they can be filtered separately in userspace.
  *
+ * In addition to the controls fields, tgid and fd are also added in each trace events.
+ * This allows to identify controls set by a specific process and to match them with other events
+ * from the same process.
+ * tgid contains the process id that opened the video device.
+ * fd is the file descriptor in the tgid, used in case a process opens multiple video devices.
+ *
  * Currently only the codec controls are supported.
  */
 
 /* AV1 controls */
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field(__u32, flags)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_sequence *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u32, flags)
 			 __field(__u8, seq_profile)
 			 __field(__u8, order_hint_bits)
 			 __field(__u8, bit_depth)
 			 __field(__u16, max_frame_width_minus_1)
 			 __field(__u16, max_frame_height_minus_1)),
-	TP_fast_assign(__entry->flags = s->flags;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->flags = s->flags;
 		       __entry->seq_profile = s->seq_profile;
 		       __entry->order_hint_bits = s->order_hint_bits;
 		       __entry->bit_depth = s->bit_depth;
 		       __entry->max_frame_width_minus_1 = s->max_frame_width_minus_1;
 		       __entry->max_frame_height_minus_1 = s->max_frame_height_minus_1;),
-	TP_printk("\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nflags %s\nseq_profile: %u\norder_hint_bits: %u\nbit_depth: %u\n"
 		  "max_frame_width_minus_1: %u\nmax_frame_height_minus_1: %u\n",
+		  __entry->tgid, __entry->fd,
 		  __print_flags(__entry->flags, "|",
 		  {V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE, "STILL_PICTURE"},
 		  {V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK, "USE_128X128_SUPERBLOCK"},
@@ -65,17 +77,23 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_seq_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
-	TP_ARGS(t),
-	TP_STRUCT__entry(__field(__u32, tile_offset)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_tile_group_entry *t),
+	TP_ARGS(tgid, fd, t),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u32, tile_offset)
 			 __field(__u32, tile_size)
 			 __field(__u32, tile_row)
 			 __field(__u32, tile_col)),
-	TP_fast_assign(__entry->tile_offset = t->tile_offset;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->tile_offset = t->tile_offset;
 		       __entry->tile_size = t->tile_size;
 		       __entry->tile_row = t->tile_row;
 		       __entry->tile_col = t->tile_col;),
-	TP_printk("\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
+	TP_printk("tgid = %u, fd = %u, "
+		  "\ntile_offset: %u\n tile_size: %u\n tile_row: %u\ntile_col: %u\n",
+		  __entry->tgid, __entry->fd,
 		  __entry->tile_offset,
 		  __entry->tile_size,
 		  __entry->tile_row,
@@ -84,9 +102,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_tge_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field(u8, tile_info_flags)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_frame *f),
+	TP_ARGS(tgid, fd, f),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u8, tile_info_flags)
 			 __field(u8, tile_info_context_update_tile_id)
 			 __field(u8, tile_info_tile_cols)
 			 __field(u8, tile_info_tile_rows)
@@ -144,7 +164,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 			 __array(u64, reference_frame_ts, V4L2_AV1_TOTAL_REFS_PER_FRAME)
 			 __array(s8, ref_frame_idx, V4L2_AV1_REFS_PER_FRAME)
 			 __field(u8, refresh_frame_flags)),
-	TP_fast_assign(__entry->tile_info_flags = f->tile_info.flags;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->tile_info_flags = f->tile_info.flags;
 		       __entry->tile_info_context_update_tile_id =
 				f->tile_info.context_update_tile_id;
 		       __entry->tile_info_tile_cols = f->tile_info.tile_cols;
@@ -226,7 +248,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 		       memcpy(__entry->ref_frame_idx, f->ref_frame_idx,
 			      sizeof(__entry->ref_frame_idx));
 		       __entry->refresh_frame_flags = f->refresh_frame_flags;),
-	TP_printk("\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\ntile_info.flags: %s\ntile_info.context_update_tile_id: %u\n"
 		  "tile_info.tile_cols: %u\ntile_info.tile_rows: %u\n"
 		  "tile_info.mi_col_starts: %s\ntile_info.mi_row_starts: %s\n"
 		  "tile_info.width_in_sbs_minus_1: %s\ntile_info.height_in_sbs_minus_1: %s\n"
@@ -250,6 +273,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 		  "render_width_minus_1: %u\nrender_height_minus_1: %u\ncurrent_frame_id: %u\n"
 		  "buffer_removal_time: %s\norder_hints: %s\nreference_frame_ts: %s\n"
 		  "ref_frame_idx: %s\nrefresh_frame_flags: %u\n",
+		  __entry->tgid, __entry->fd,
 		  __print_flags(__entry->tile_info_flags, "|",
 		  {V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING, "UNIFORM_TILE_SPACING"}),
 		  __entry->tile_info_context_update_tile_id,
@@ -385,9 +409,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_frame_tmpl,
 
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__field(__u8, flags)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_film_grain *f),
+	TP_ARGS(tgid, fd, f),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u8, flags)
 			 __field(__u8, cr_mult)
 			 __field(__u16, grain_seed)
 			 __field(__u8, film_grain_params_ref_idx)
@@ -412,7 +438,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
 			 __field(__u8, cr_luma_mult)
 			 __field(__u16, cb_offset)
 			 __field(__u16, cr_offset)),
-	TP_fast_assign(__entry->flags = f->flags;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->flags = f->flags;
 		       __entry->cr_mult = f->cr_mult;
 		       __entry->grain_seed = f->grain_seed;
 		       __entry->film_grain_params_ref_idx = f->film_grain_params_ref_idx;
@@ -446,7 +474,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
 		       __entry->cr_luma_mult = f->cr_luma_mult;
 		       __entry->cb_offset = f->cb_offset;
 		       __entry->cr_offset = f->cr_offset;),
-	TP_printk("\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nflags %s\ncr_mult: %u\ngrain_seed: %u\n"
 		  "film_grain_params_ref_idx: %u\nnum_y_points: %u\npoint_y_value: %s\n"
 		  "point_y_scaling: %s\nnum_cb_points: %u\npoint_cb_value: %s\n"
 		  "point_cb_scaling: %s\nnum_cr_points: %u\npoint_cr_value: %s\n"
@@ -455,6 +484,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
 		  "ar_coeffs_cr_plus_128: %s\nar_coeff_shift_minus_6: %u\n"
 		  "grain_scale_shift: %u\ncb_mult: %u\ncb_luma_mult: %u\ncr_luma_mult: %u\n"
 		  "cb_offset: %u\ncr_offset: %u\n",
+		  __entry->tgid, __entry->fd,
 		  __print_flags(__entry->flags, "|",
 		  {V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN, "APPLY_GRAIN"},
 		  {V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN, "UPDATE_GRAIN"},
@@ -507,31 +537,32 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_av1_film_grain_tmpl,
 )
 
 DEFINE_EVENT(v4l2_ctrl_av1_seq_tmpl, v4l2_ctrl_av1_sequence,
-	TP_PROTO(const struct v4l2_ctrl_av1_sequence *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_sequence *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_ctrl_av1_frame_tmpl, v4l2_ctrl_av1_frame,
-	TP_PROTO(const struct v4l2_ctrl_av1_frame *f),
-	TP_ARGS(f)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_frame *f),
+	TP_ARGS(tgid, fd, f)
 );
 
 DEFINE_EVENT(v4l2_ctrl_av1_tge_tmpl, v4l2_ctrl_av1_tile_group_entry,
-	TP_PROTO(const struct v4l2_ctrl_av1_tile_group_entry *t),
-	TP_ARGS(t)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_tile_group_entry *t),
+	TP_ARGS(tgid, fd, t)
 );
 
 DEFINE_EVENT(v4l2_ctrl_av1_film_grain_tmpl, v4l2_ctrl_av1_film_grain,
-	TP_PROTO(const struct v4l2_ctrl_av1_film_grain *f),
-	TP_ARGS(f)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_av1_film_grain *f),
+	TP_ARGS(tgid, fd, f)
 );
 
 /* FWHT controls */
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_fwht_params *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
 			 __field(u64, backward_ref_ts)
 			 __field(u32, version)
 			 __field(u32, width)
@@ -542,7 +573,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
 			 __field(u32, ycbcr_enc)
 			 __field(u32, quantization)
 			 ),
-	TP_fast_assign(
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
 		       __entry->backward_ref_ts = p->backward_ref_ts;
 		       __entry->version = p->version;
 		       __entry->width = p->width;
@@ -553,8 +585,10 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
 		       __entry->ycbcr_enc = p->ycbcr_enc;
 		       __entry->quantization = p->quantization;
 		       ),
-	TP_printk("backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u "
+	TP_printk("tgid = %u, fd = %u, "
+		  "backward_ref_ts %llu version %u width %u height %u flags %s colorspace %u "
 		  "xfer_func %u ycbcr_enc %u quantization %u",
+		  __entry->tgid, __entry->fd,
 		  __entry->backward_ref_ts, __entry->version, __entry->width, __entry->height,
 		  __print_flags(__entry->flags, "|",
 		  {V4L2_FWHT_FL_IS_INTERLACED, "IS_INTERLACED"},
@@ -574,16 +608,18 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_fwht_params_tmpl,
 );
 
 DEFINE_EVENT(v4l2_ctrl_fwht_params_tmpl, v4l2_ctrl_fwht_params,
-	TP_PROTO(const struct v4l2_ctrl_fwht_params *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_fwht_params *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 /* H264 controls */
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field(u8, profile_idc)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_sps *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u8, profile_idc)
 			 __field(u8, constraint_set_flags)
 			 __field(u8, level_idc)
 			 __field(u8, seq_parameter_set_id)
@@ -601,7 +637,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 			 __field(u16, pic_width_in_mbs_minus1)
 			 __field(u16, pic_height_in_map_units_minus1)
 			 __field(u32, flags)),
-	TP_fast_assign(__entry->profile_idc = s->profile_idc;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->profile_idc = s->profile_idc;
 		       __entry->constraint_set_flags = s->constraint_set_flags;
 		       __entry->level_idc = s->level_idc;
 		       __entry->seq_parameter_set_id = s->seq_parameter_set_id;
@@ -622,7 +660,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 		       __entry->pic_width_in_mbs_minus1 = s->pic_width_in_mbs_minus1;
 		       __entry->pic_height_in_map_units_minus1 = s->pic_height_in_map_units_minus1;
 		       __entry->flags = s->flags),
-	TP_printk("\nprofile_idc %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nprofile_idc %u\n"
 		  "constraint_set_flags %s\n"
 		  "level_idc %u\n"
 		  "seq_parameter_set_id %u\n"
@@ -640,6 +679,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 		  "pic_width_in_mbs_minus1 %u\n"
 		  "pic_height_in_map_units_minus1 %u\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->profile_idc,
 		  __print_flags(__entry->constraint_set_flags, "|",
 		  {V4L2_H264_SPS_CONSTRAINT_SET0_FLAG, "CONSTRAINT_SET0_FLAG"},
@@ -679,9 +719,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_sps_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field(u8, pic_parameter_set_id)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pps *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u8, pic_parameter_set_id)
 			 __field(u8, seq_parameter_set_id)
 			 __field(u8, num_slice_groups_minus1)
 			 __field(u8, num_ref_idx_l0_default_active_minus1)
@@ -692,7 +734,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 			 __field(__s8, chroma_qp_index_offset)
 			 __field(__s8, second_chroma_qp_index_offset)
 			 __field(u16, flags)),
-	TP_fast_assign(__entry->pic_parameter_set_id = p->pic_parameter_set_id;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->pic_parameter_set_id = p->pic_parameter_set_id;
 		       __entry->seq_parameter_set_id = p->seq_parameter_set_id;
 		       __entry->num_slice_groups_minus1 = p->num_slice_groups_minus1;
 		       __entry->num_ref_idx_l0_default_active_minus1 =
@@ -705,7 +749,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 		       __entry->chroma_qp_index_offset = p->chroma_qp_index_offset;
 		       __entry->second_chroma_qp_index_offset = p->second_chroma_qp_index_offset;
 		       __entry->flags = p->flags),
-	TP_printk("\npic_parameter_set_id %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\npic_parameter_set_id %u\n"
 		  "seq_parameter_set_id %u\n"
 		  "num_slice_groups_minus1 %u\n"
 		  "num_ref_idx_l0_default_active_minus1 %u\n"
@@ -716,6 +761,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 		  "chroma_qp_index_offset %d\n"
 		  "second_chroma_qp_index_offset %d\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->pic_parameter_set_id,
 		  __entry->seq_parameter_set_id,
 		  __entry->num_slice_groups_minus1,
@@ -741,15 +787,21 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pps_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__array(u8, scaling_list_4x4, 6 * 16)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_scaling_matrix *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(u8, scaling_list_4x4, 6 * 16)
 			 __array(u8, scaling_list_8x8, 6 * 64)),
-	TP_fast_assign(memcpy(__entry->scaling_list_4x4, s->scaling_list_4x4,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->scaling_list_4x4, s->scaling_list_4x4,
 			      sizeof(__entry->scaling_list_4x4));
 		       memcpy(__entry->scaling_list_8x8, s->scaling_list_8x8,
 			      sizeof(__entry->scaling_list_8x8))),
-	TP_printk("\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nscaling_list_4x4 {%s}\nscaling_list_8x8 {%s}",
+		  __entry->tgid, __entry->fd,
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
 				   __entry->scaling_list_4x4,
 				   sizeof(__entry->scaling_list_4x4),
@@ -762,9 +814,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_scaling_matrix_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field(u16, luma_log2_weight_denom)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pred_weights *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u16, luma_log2_weight_denom)
 			 __field(u16, chroma_log2_weight_denom)
 			 __array(__s16, weight_factors_0_luma_weight, 32)
 			 __array(__s16, weight_factors_0_luma_offset, 32)
@@ -774,7 +828,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 			 __array(__s16, weight_factors_1_luma_offset, 32)
 			 __array(__s16, weight_factors_1_chroma_weight, 32 * 2)
 			 __array(__s16, weight_factors_1_chroma_offset, 32 * 2)),
-	TP_fast_assign(__entry->luma_log2_weight_denom = p->luma_log2_weight_denom;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->luma_log2_weight_denom = p->luma_log2_weight_denom;
 		       __entry->chroma_log2_weight_denom = p->chroma_log2_weight_denom;
 		       memcpy(__entry->weight_factors_0_luma_weight,
 			      p->weight_factors[0].luma_weight,
@@ -800,7 +856,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 		       memcpy(__entry->weight_factors_1_chroma_offset,
 			      p->weight_factors[1].chroma_offset,
 			      sizeof(__entry->weight_factors_1_chroma_offset))),
-	TP_printk("\nluma_log2_weight_denom %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nluma_log2_weight_denom %u\n"
 		  "chroma_log2_weight_denom %u\n"
 		  "weight_factor[0].luma_weight %s\n"
 		  "weight_factor[0].luma_offset %s\n"
@@ -810,6 +867,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 		  "weight_factor[1].luma_offset %s\n"
 		  "weight_factor[1].chroma_weight {%s}\n"
 		  "weight_factor[1].chroma_offset {%s}\n",
+		  __entry->tgid, __entry->fd,
 		  __entry->luma_log2_weight_denom,
 		  __entry->chroma_log2_weight_denom,
 		  __print_array(__entry->weight_factors_0_luma_weight,
@@ -844,9 +902,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_pred_weights_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field(u32, header_bit_size)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_slice_params *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u32, header_bit_size)
 			 __field(u32, first_mb_in_slice)
 			 __field(u8, slice_type)
 			 __field(u8, colour_plane_id)
@@ -860,7 +920,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 			 __field(u8, num_ref_idx_l0_active_minus1)
 			 __field(u8, num_ref_idx_l1_active_minus1)
 			 __field(u32, flags)),
-	TP_fast_assign(__entry->header_bit_size = s->header_bit_size;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->header_bit_size = s->header_bit_size;
 		       __entry->first_mb_in_slice = s->first_mb_in_slice;
 		       __entry->slice_type = s->slice_type;
 		       __entry->colour_plane_id = s->colour_plane_id;
@@ -874,7 +936,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 		       __entry->num_ref_idx_l0_active_minus1 = s->num_ref_idx_l0_active_minus1;
 		       __entry->num_ref_idx_l1_active_minus1 = s->num_ref_idx_l1_active_minus1;
 		       __entry->flags = s->flags),
-	TP_printk("\nheader_bit_size %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nheader_bit_size %u\n"
 		  "first_mb_in_slice %u\n"
 		  "slice_type %s\n"
 		  "colour_plane_id %u\n"
@@ -888,6 +951,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 		  "num_ref_idx_l0_active_minus1 %u\n"
 		  "num_ref_idx_l1_active_minus1 %u\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->header_bit_size,
 		  __entry->first_mb_in_slice,
 		  __print_symbolic(__entry->slice_type,
@@ -913,15 +977,21 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_slice_params_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
-	TP_PROTO(const struct v4l2_h264_reference *r, int i),
-	TP_ARGS(r, i),
-	TP_STRUCT__entry(__field(u8, fields)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_reference *r, int i),
+	TP_ARGS(tgid, fd, r, i),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u8, fields)
 			 __field(u8, index)
 			 __field(int, i)),
-	TP_fast_assign(__entry->fields = r->fields;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->fields = r->fields;
 		       __entry->index = r->index;
 		       __entry->i = i;),
-	TP_printk("[%d]: fields %s index %u",
+	TP_printk("tgid = %u, fd = %u, "
+		  "[%d]: fields %s index %u",
+		  __entry->tgid, __entry->fd,
 		  __entry->i,
 		  __print_flags(__entry->fields, "|",
 		  {V4L2_H264_TOP_FIELD_REF, "TOP_FIELD_REF"},
@@ -932,9 +1002,11 @@ DECLARE_EVENT_CLASS(v4l2_h264_reference_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
-	TP_ARGS(d),
-	TP_STRUCT__entry(__field(u16, nal_ref_idc)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_decode_params *d),
+	TP_ARGS(tgid, fd, d),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u16, nal_ref_idc)
 			 __field(u16, frame_num)
 			 __field(__s32, top_field_order_cnt)
 			 __field(__s32, bottom_field_order_cnt)
@@ -947,7 +1019,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 			 __field(u32, pic_order_cnt_bit_size)
 			 __field(u32, slice_group_change_cycle)
 			 __field(u32, flags)),
-	TP_fast_assign(__entry->nal_ref_idc = d->nal_ref_idc;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->nal_ref_idc = d->nal_ref_idc;
 		       __entry->frame_num = d->frame_num;
 		       __entry->top_field_order_cnt = d->top_field_order_cnt;
 		       __entry->bottom_field_order_cnt = d->bottom_field_order_cnt;
@@ -960,7 +1034,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 		       __entry->pic_order_cnt_bit_size = d->pic_order_cnt_bit_size;
 		       __entry->slice_group_change_cycle = d->slice_group_change_cycle;
 		       __entry->flags = d->flags),
-	TP_printk("\nnal_ref_idc %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nnal_ref_idc %u\n"
 		  "frame_num %u\n"
 		  "top_field_order_cnt %d\n"
 		  "bottom_field_order_cnt %d\n"
@@ -973,6 +1048,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 		  "pic_order_cnt_bit_size %u\n"
 		  "slice_group_change_cycle %u\n"
 		  "flags %s\n",
+		  __entry->tgid, __entry->fd,
 		  __entry->nal_ref_idc,
 		  __entry->frame_num,
 		  __entry->top_field_order_cnt,
@@ -995,9 +1071,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_h264_decode_params_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
-	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
-	TP_ARGS(e, i),
-	TP_STRUCT__entry(__field(u64, reference_ts)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_dpb_entry *e, int i),
+	TP_ARGS(tgid, fd, e, i),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(u64, reference_ts)
 			 __field(u32, pic_num)
 			 __field(u16, frame_num)
 			 __field(u8, fields)
@@ -1005,7 +1083,9 @@ DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
 			 __field(__s32, bottom_field_order_cnt)
 			 __field(u32, flags)
 			 __field(int, i)),
-	TP_fast_assign(__entry->reference_ts = e->reference_ts;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->reference_ts = e->reference_ts;
 		       __entry->pic_num = e->pic_num;
 		       __entry->frame_num = e->frame_num;
 		       __entry->fields = e->fields;
@@ -1013,8 +1093,10 @@ DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
 		       __entry->bottom_field_order_cnt = e->bottom_field_order_cnt;
 		       __entry->flags = e->flags;
 		       __entry->i = i;),
-	TP_printk("[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
+	TP_printk("tgid = %u, fd = %u, "
+		  "[%d]: reference_ts %llu, pic_num %u frame_num %u fields %s "
 		  "top_field_order_cnt %d bottom_field_order_cnt %d flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->i,
 		  __entry->reference_ts,
 		  __entry->pic_num,
@@ -1035,56 +1117,58 @@ DECLARE_EVENT_CLASS(v4l2_h264_dpb_entry_tmpl,
 );
 
 DEFINE_EVENT(v4l2_ctrl_h264_sps_tmpl, v4l2_ctrl_h264_sps,
-	TP_PROTO(const struct v4l2_ctrl_h264_sps *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_sps *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_ctrl_h264_pps_tmpl, v4l2_ctrl_h264_pps,
-	TP_PROTO(const struct v4l2_ctrl_h264_pps *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pps *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 DEFINE_EVENT(v4l2_ctrl_h264_scaling_matrix_tmpl, v4l2_ctrl_h264_scaling_matrix,
-	TP_PROTO(const struct v4l2_ctrl_h264_scaling_matrix *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_scaling_matrix *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_ctrl_h264_pred_weights_tmpl, v4l2_ctrl_h264_pred_weights,
-	TP_PROTO(const struct v4l2_ctrl_h264_pred_weights *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_pred_weights *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 DEFINE_EVENT(v4l2_ctrl_h264_slice_params_tmpl, v4l2_ctrl_h264_slice_params,
-	TP_PROTO(const struct v4l2_ctrl_h264_slice_params *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_slice_params *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list0,
-	TP_PROTO(const struct v4l2_h264_reference *r, int i),
-	TP_ARGS(r, i)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_reference *r, int i),
+	TP_ARGS(tgid, fd, r, i)
 );
 
 DEFINE_EVENT(v4l2_h264_reference_tmpl, v4l2_h264_ref_pic_list1,
-	TP_PROTO(const struct v4l2_h264_reference *r, int i),
-	TP_ARGS(r, i)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_reference *r, int i),
+	TP_ARGS(tgid, fd, r, i)
 );
 
 DEFINE_EVENT(v4l2_ctrl_h264_decode_params_tmpl, v4l2_ctrl_h264_decode_params,
-	TP_PROTO(const struct v4l2_ctrl_h264_decode_params *d),
-	TP_ARGS(d)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_h264_decode_params *d),
+	TP_ARGS(tgid, fd, d)
 );
 
 DEFINE_EVENT(v4l2_h264_dpb_entry_tmpl, v4l2_h264_dpb_entry,
-	TP_PROTO(const struct v4l2_h264_dpb_entry *e, int i),
-	TP_ARGS(e, i)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_h264_dpb_entry *e, int i),
+	TP_ARGS(tgid, fd, e, i)
 );
 
 /* HEVC controls */
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field(__u8, video_parameter_set_id)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_sps *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u8, video_parameter_set_id)
 			 __field(__u8, seq_parameter_set_id)
 			 __field(__u16, pic_width_in_luma_samples)
 			 __field(__u16, pic_height_in_luma_samples)
@@ -1109,7 +1193,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 			 __field(__u8, chroma_format_idc)
 			 __field(__u8, sps_max_sub_layers_minus1)
 			 __field(__u64, flags)),
-	TP_fast_assign(__entry->video_parameter_set_id = s->video_parameter_set_id;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->video_parameter_set_id = s->video_parameter_set_id;
 		       __entry->seq_parameter_set_id = s->seq_parameter_set_id;
 		       __entry->pic_width_in_luma_samples = s->pic_width_in_luma_samples;
 		       __entry->pic_height_in_luma_samples = s->pic_height_in_luma_samples;
@@ -1146,7 +1232,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 		       __entry->chroma_format_idc = s->chroma_format_idc;
 		       __entry->sps_max_sub_layers_minus1 = s->sps_max_sub_layers_minus1;
 		       __entry->flags = s->flags;),
-	TP_printk("\nvideo_parameter_set_id %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nvideo_parameter_set_id %u\n"
 		  "seq_parameter_set_id %u\n"
 		  "pic_width_in_luma_samples %u\n"
 		  "pic_height_in_luma_samples %u\n"
@@ -1171,6 +1258,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 		  "chroma_format_idc %u\n"
 		  "sps_max_sub_layers_minus1 %u\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->video_parameter_set_id,
 		  __entry->seq_parameter_set_id,
 		  __entry->pic_width_in_luma_samples,
@@ -1213,9 +1301,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_sps_tmpl,
 
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field(__u8, pic_parameter_set_id)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_pps *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u8, pic_parameter_set_id)
 			 __field(__u8, num_extra_slice_header_bits)
 			 __field(__u8, num_ref_idx_l0_default_active_minus1)
 			 __field(__u8, num_ref_idx_l1_default_active_minus1)
@@ -1231,7 +1321,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 			 __field(__s8, pps_tc_offset_div2)
 			 __field(__u8, log2_parallel_merge_level_minus2)
 			 __field(__u64, flags)),
-	TP_fast_assign(__entry->pic_parameter_set_id = p->pic_parameter_set_id;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->pic_parameter_set_id = p->pic_parameter_set_id;
 		       __entry->num_extra_slice_header_bits = p->num_extra_slice_header_bits;
 		       __entry->num_ref_idx_l0_default_active_minus1 =
 				p->num_ref_idx_l0_default_active_minus1;
@@ -1252,7 +1344,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 		       __entry->log2_parallel_merge_level_minus2 =
 				p->log2_parallel_merge_level_minus2;
 		       __entry->flags = p->flags;),
-	TP_printk("\npic_parameter_set_id %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\npic_parameter_set_id %u\n"
 		  "num_extra_slice_header_bits %u\n"
 		  "num_ref_idx_l0_default_active_minus1 %u\n"
 		  "num_ref_idx_l1_default_active_minus1 %u\n"
@@ -1268,6 +1361,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 		  "pps_tc_offset_div2 %d\n"
 		  "log2_parallel_merge_level_minus2 %u\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->pic_parameter_set_id,
 		  __entry->num_extra_slice_header_bits,
 		  __entry->num_ref_idx_l0_default_active_minus1,
@@ -1322,9 +1416,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_pps_tmpl,
 
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field(__u32, bit_size)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_slice_params *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u32, bit_size)
 			 __field(__u32, data_byte_offset)
 			 __field(__u32, num_entry_point_offsets)
 			 __field(__u8, nal_unit_type)
@@ -1351,7 +1447,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 			 __field(__u16, short_term_ref_pic_set_size)
 			 __field(__u16, long_term_ref_pic_set_size)
 			 __field(__u64, flags)),
-	TP_fast_assign(__entry->bit_size = s->bit_size;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->bit_size = s->bit_size;
 		       __entry->data_byte_offset = s->data_byte_offset;
 		       __entry->num_entry_point_offsets = s->num_entry_point_offsets;
 		       __entry->nal_unit_type = s->nal_unit_type;
@@ -1378,7 +1476,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 		       __entry->short_term_ref_pic_set_size = s->short_term_ref_pic_set_size;
 		       __entry->long_term_ref_pic_set_size = s->long_term_ref_pic_set_size;
 		       __entry->flags = s->flags;),
-	TP_printk("\nbit_size %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nbit_size %u\n"
 		  "data_byte_offset %u\n"
 		  "num_entry_point_offsets %u\n"
 		  "nal_unit_type %u\n"
@@ -1405,6 +1504,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 		  "short_term_ref_pic_set_size %u\n"
 		  "long_term_ref_pic_set_size %u\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->bit_size,
 		  __entry->data_byte_offset,
 		  __entry->num_entry_point_offsets,
@@ -1454,9 +1554,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_slice_params_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
-	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__array(__s8, delta_luma_weight_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_pred_weight_table *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__s8, delta_luma_weight_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
 			 __array(__s8, luma_offset_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
 			 __array(__s8, delta_chroma_weight_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
 			 __array(__s8, chroma_offset_l0, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
@@ -1466,7 +1568,9 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
 			 __array(__s8, chroma_offset_l1, V4L2_HEVC_DPB_ENTRIES_NUM_MAX * 2)
 			 __field(__u8, luma_log2_weight_denom)
 			 __field(__s8, delta_chroma_log2_weight_denom)),
-	TP_fast_assign(memcpy(__entry->delta_luma_weight_l0, p->delta_luma_weight_l0,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->delta_luma_weight_l0, p->delta_luma_weight_l0,
 			      sizeof(__entry->delta_luma_weight_l0));
 		       memcpy(__entry->luma_offset_l0, p->luma_offset_l0,
 			      sizeof(__entry->luma_offset_l0));
@@ -1485,7 +1589,8 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
 		       __entry->luma_log2_weight_denom = p->luma_log2_weight_denom;
 		       __entry->delta_chroma_log2_weight_denom =
 				p->delta_chroma_log2_weight_denom;),
-	TP_printk("\ndelta_luma_weight_l0 %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\ndelta_luma_weight_l0 %s\n"
 		  "luma_offset_l0 %s\n"
 		  "delta_chroma_weight_l0 {%s}\n"
 		  "chroma_offset_l0 {%s}\n"
@@ -1495,6 +1600,7 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
 		  "chroma_offset_l1 {%s}\n"
 		  "luma_log2_weight_denom %d\n"
 		  "delta_chroma_log2_weight_denom %d\n",
+		  __entry->tgid, __entry->fd,
 		  __print_array(__entry->delta_luma_weight_l0,
 				ARRAY_SIZE(__entry->delta_luma_weight_l0),
 				sizeof(__entry->delta_luma_weight_l0[0])),
@@ -1529,15 +1635,19 @@ DECLARE_EVENT_CLASS(v4l2_hevc_pred_weight_table_tmpl,
 	))
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__array(__u8, scaling_list_4x4, 6 * 16)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_scaling_matrix *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__u8, scaling_list_4x4, 6 * 16)
 			 __array(__u8, scaling_list_8x8, 6 * 64)
 			 __array(__u8, scaling_list_16x16, 6 * 64)
 			 __array(__u8, scaling_list_32x32, 2 * 64)
 			 __array(__u8, scaling_list_dc_coef_16x16, 6)
 			 __array(__u8, scaling_list_dc_coef_32x32, 2)),
-	TP_fast_assign(memcpy(__entry->scaling_list_4x4,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->scaling_list_4x4,
 			      s->scaling_list_4x4, sizeof(__entry->scaling_list_4x4));
 		       memcpy(__entry->scaling_list_8x8,
 			      s->scaling_list_8x8, sizeof(__entry->scaling_list_8x8));
@@ -1551,12 +1661,14 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
 		       memcpy(__entry->scaling_list_dc_coef_32x32,
 			      s->scaling_list_dc_coef_32x32,
 			      sizeof(__entry->scaling_list_dc_coef_32x32));),
-	TP_printk("\nscaling_list_4x4 {%s}\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nscaling_list_4x4 {%s}\n"
 		  "scaling_list_8x8 {%s}\n"
 		  "scaling_list_16x16 {%s}\n"
 		  "scaling_list_32x32 {%s}\n"
 		  "scaling_list_dc_coef_16x16 %s\n"
 		  "scaling_list_dc_coef_32x32 %s\n",
+		  __entry->tgid, __entry->fd,
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
 				   __entry->scaling_list_4x4,
 				   sizeof(__entry->scaling_list_4x4),
@@ -1582,9 +1694,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_scaling_matrix_tmpl,
 	))
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
-	TP_ARGS(d),
-	TP_STRUCT__entry(__field(__s32, pic_order_cnt_val)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_decode_params *d),
+	TP_ARGS(tgid, fd, d),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__s32, pic_order_cnt_val)
 			 __field(__u16, short_term_ref_pic_set_size)
 			 __field(__u16, long_term_ref_pic_set_size)
 			 __field(__u8, num_active_dpb_entries)
@@ -1595,7 +1709,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 			 __array(__u8, poc_st_curr_after, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
 			 __array(__u8, poc_lt_curr, V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
 			 __field(__u64, flags)),
-	TP_fast_assign(__entry->pic_order_cnt_val = d->pic_order_cnt_val;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->pic_order_cnt_val = d->pic_order_cnt_val;
 		       __entry->short_term_ref_pic_set_size = d->short_term_ref_pic_set_size;
 		       __entry->long_term_ref_pic_set_size = d->long_term_ref_pic_set_size;
 		       __entry->num_active_dpb_entries = d->num_active_dpb_entries;
@@ -1608,7 +1724,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 			      sizeof(__entry->poc_st_curr_after));
 		       memcpy(__entry->poc_lt_curr, d->poc_lt_curr, sizeof(__entry->poc_lt_curr));
 		       __entry->flags = d->flags;),
-	TP_printk("\npic_order_cnt_val %d\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\npic_order_cnt_val %d\n"
 		  "short_term_ref_pic_set_size %u\n"
 		  "long_term_ref_pic_set_size %u\n"
 		  "num_active_dpb_entries %u\n"
@@ -1619,6 +1736,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 		  "poc_st_curr_after %s\n"
 		  "poc_lt_curr %s\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __entry->pic_order_cnt_val,
 		  __entry->short_term_ref_pic_set_size,
 		  __entry->long_term_ref_pic_set_size,
@@ -1643,14 +1761,20 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_decode_params_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
-	TP_ARGS(lt),
-	TP_STRUCT__entry(__field(__u8, flags)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+	TP_ARGS(tgid, fd, lt),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u8, flags)
 			 __field(__u32, lt_ref_pic_poc_lsb_sps)),
-	TP_fast_assign(__entry->flags = lt->flags;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->flags = lt->flags;
 		       __entry->lt_ref_pic_poc_lsb_sps = lt->lt_ref_pic_poc_lsb_sps;),
-	TP_printk("\nflags %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nflags %s\n"
 		  "lt_ref_pic_poc_lsb_sps %x\n",
+		  __entry->tgid, __entry->fd,
 		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT, "USED_LT"}
 		  ),
@@ -1659,9 +1783,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
-	TP_ARGS(st),
-	TP_STRUCT__entry(__field(__u8, flags)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+	TP_ARGS(tgid, fd, st),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u8, flags)
 			 __field(__u8, delta_idx_minus1)
 			 __field(__u8, delta_rps_sign)
 			 __field(__u16, abs_delta_rps_minus1)
@@ -1671,7 +1797,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
 			 __field(__u32, use_delta_flag)
 			 __array(__u32, delta_poc_s0_minus1, 16)
 			 __array(__u32, delta_poc_s1_minus1, 16)),
-	TP_fast_assign(__entry->flags = st->flags;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->flags = st->flags;
 		       __entry->delta_idx_minus1 = st->delta_idx_minus1;
 		       __entry->delta_rps_sign = st->delta_rps_sign;
 		       __entry->abs_delta_rps_minus1 = st->abs_delta_rps_minus1;
@@ -1683,7 +1811,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
 			      sizeof(__entry->delta_poc_s0_minus1));
 		       memcpy(__entry->delta_poc_s1_minus1, st->delta_poc_s1_minus1,
 			      sizeof(__entry->delta_poc_s1_minus1));),
-	TP_printk("\nflags %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nflags %s\n"
 		  "delta_idx_minus1: %u\n"
 		  "delta_rps_sign: %u\n"
 		  "abs_delta_rps_minus1: %u\n"
@@ -1693,6 +1822,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
 		  "use_delta_flag: %08x\n"
 		  "delta_poc_s0_minus1: %s\n"
 		  "delta_poc_s1_minus1: %s\n",
+		  __entry->tgid, __entry->fd,
 		  __print_flags(__entry->flags, "|",
 		  {V4L2_HEVC_EXT_SPS_ST_RPS_FLAG_INTER_REF_PIC_SET_PRED, "INTER_REF_PIC_SET_PRED"}
 		  ),
@@ -1713,20 +1843,26 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
-	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
-	TP_ARGS(e),
-	TP_STRUCT__entry(__field(__u64, timestamp)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_dpb_entry *e),
+	TP_ARGS(tgid, fd, e),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u64, timestamp)
 			 __field(__u8, flags)
 			 __field(__u8, field_pic)
 			 __field(__s32, pic_order_cnt_val)),
-	TP_fast_assign(__entry->timestamp = e->timestamp;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->timestamp = e->timestamp;
 		       __entry->flags = e->flags;
 		       __entry->field_pic = e->field_pic;
 		       __entry->pic_order_cnt_val = e->pic_order_cnt_val;),
-	TP_printk("\ntimestamp %llu\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\ntimestamp %llu\n"
 		  "flags %s\n"
 		  "field_pic %u\n"
 		  "pic_order_cnt_val %d\n",
+		  __entry->tgid, __entry->fd,
 		__entry->timestamp,
 		__print_flags(__entry->flags, "|",
 		{V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE, "LONG_TERM_REFERENCE"}
@@ -1736,69 +1872,75 @@ DECLARE_EVENT_CLASS(v4l2_hevc_dpb_entry_tmpl,
 	))
 
 DEFINE_EVENT(v4l2_ctrl_hevc_sps_tmpl, v4l2_ctrl_hevc_sps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_sps *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_sps *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_ctrl_hevc_pps_tmpl, v4l2_ctrl_hevc_pps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_pps *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_pps *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 DEFINE_EVENT(v4l2_ctrl_hevc_slice_params_tmpl, v4l2_ctrl_hevc_slice_params,
-	TP_PROTO(const struct v4l2_ctrl_hevc_slice_params *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_slice_params *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_hevc_pred_weight_table_tmpl, v4l2_hevc_pred_weight_table,
-	TP_PROTO(const struct v4l2_hevc_pred_weight_table *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_pred_weight_table *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 DEFINE_EVENT(v4l2_ctrl_hevc_scaling_matrix_tmpl, v4l2_ctrl_hevc_scaling_matrix,
-	TP_PROTO(const struct v4l2_ctrl_hevc_scaling_matrix *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_scaling_matrix *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_ctrl_hevc_decode_params_tmpl, v4l2_ctrl_hevc_decode_params,
-	TP_PROTO(const struct v4l2_ctrl_hevc_decode_params *d),
-	TP_ARGS(d)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_decode_params *d),
+	TP_ARGS(tgid, fd, d)
 );
 
 DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_lt_rps_tmpl, v4l2_ctrl_hevc_ext_sps_lt_rps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
-	TP_ARGS(lt)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_lt_rps *lt),
+	TP_ARGS(tgid, fd, lt)
 );
 
 DEFINE_EVENT(v4l2_ctrl_hevc_ext_sps_st_rps_tmpl, v4l2_ctrl_hevc_ext_sps_st_rps,
-	TP_PROTO(const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
-	TP_ARGS(st)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_hevc_ext_sps_st_rps *st),
+	TP_ARGS(tgid, fd, st)
 );
 
 DEFINE_EVENT(v4l2_hevc_dpb_entry_tmpl, v4l2_hevc_dpb_entry,
-	TP_PROTO(const struct v4l2_hevc_dpb_entry *e),
-	TP_ARGS(e)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_hevc_dpb_entry *e),
+	TP_ARGS(tgid, fd, e)
 );
 
 /* MPEG2 controls */
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
-	TP_ARGS(s),
-	TP_STRUCT__entry(__field(__u16, horizontal_size)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_sequence *s),
+	TP_ARGS(tgid, fd, s),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u16, horizontal_size)
 			 __field(__u16, vertical_size)
 			 __field(__u32, vbv_buffer_size)
 			 __field(__u16, profile_and_level_indication)
 			 __field(__u8, chroma_format)
 			 __field(__u8, flags)),
-	TP_fast_assign(__entry->horizontal_size = s->horizontal_size;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->horizontal_size = s->horizontal_size;
 		       __entry->vertical_size = s->vertical_size;
 		       __entry->vbv_buffer_size = s->vbv_buffer_size;
 		       __entry->profile_and_level_indication = s->profile_and_level_indication;
 		       __entry->chroma_format = s->chroma_format;
 		       __entry->flags = s->flags;),
-	TP_printk("\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nhorizontal_size %u\nvertical_size %u\nvbv_buffer_size %u\n"
 		  "profile_and_level_indication %u\nchroma_format %u\nflags %s\n",
+		  __entry->tgid, __entry->fd,
 		  __entry->horizontal_size,
 		  __entry->vertical_size,
 		  __entry->vbv_buffer_size,
@@ -1810,24 +1952,30 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_seq_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__field(__u64, backward_ref_ts)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_picture *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u64, backward_ref_ts)
 			 __field(__u64, forward_ref_ts)
 			 __field(__u32, flags)
 			 __array(__u8, f_code, 4)
 			 __field(__u8, picture_coding_type)
 			 __field(__u8, picture_structure)
 			 __field(__u8, intra_dc_precision)),
-	TP_fast_assign(__entry->backward_ref_ts = p->backward_ref_ts;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->backward_ref_ts = p->backward_ref_ts;
 		       __entry->forward_ref_ts = p->forward_ref_ts;
 		       __entry->flags = p->flags;
 		       memcpy(__entry->f_code, p->f_code, sizeof(__entry->f_code));
 		       __entry->picture_coding_type = p->picture_coding_type;
 		       __entry->picture_structure = p->picture_structure;
 		       __entry->intra_dc_precision = p->intra_dc_precision;),
-	TP_printk("\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nbackward_ref_ts %llu\nforward_ref_ts %llu\nflags %s\nf_code {%s}\n"
 		  "picture_coding_type: %u\npicture_structure %u\nintra_dc_precision %u\n",
+		  __entry->tgid, __entry->fd,
 		  __entry->backward_ref_ts,
 		  __entry->forward_ref_ts,
 		  __print_flags(__entry->flags, "|",
@@ -1850,13 +1998,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_pic_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
-	TP_ARGS(q),
-	TP_STRUCT__entry(__array(__u8, intra_quantiser_matrix, 64)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_quantisation *q),
+	TP_ARGS(tgid, fd, q),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__u8, intra_quantiser_matrix, 64)
 			 __array(__u8, non_intra_quantiser_matrix, 64)
 			 __array(__u8, chroma_intra_quantiser_matrix, 64)
 			 __array(__u8, chroma_non_intra_quantiser_matrix, 64)),
-	TP_fast_assign(memcpy(__entry->intra_quantiser_matrix, q->intra_quantiser_matrix,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->intra_quantiser_matrix, q->intra_quantiser_matrix,
 			      sizeof(__entry->intra_quantiser_matrix));
 		       memcpy(__entry->non_intra_quantiser_matrix, q->non_intra_quantiser_matrix,
 			      sizeof(__entry->non_intra_quantiser_matrix));
@@ -1866,8 +2018,10 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
 		       memcpy(__entry->chroma_non_intra_quantiser_matrix,
 			      q->chroma_non_intra_quantiser_matrix,
 			      sizeof(__entry->chroma_non_intra_quantiser_matrix));),
-	TP_printk("\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nintra_quantiser_matrix %s\nnon_intra_quantiser_matrix %s\n"
 		  "chroma_intra_quantiser_matrix %s\nchroma_non_intra_quantiser_matrix %s\n",
+		  __entry->tgid, __entry->fd,
 		  __print_array(__entry->intra_quantiser_matrix,
 				ARRAY_SIZE(__entry->intra_quantiser_matrix),
 				sizeof(__entry->intra_quantiser_matrix[0])),
@@ -1884,30 +2038,34 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_mpeg2_quant_tmpl,
 )
 
 DEFINE_EVENT(v4l2_ctrl_mpeg2_seq_tmpl, v4l2_ctrl_mpeg2_sequence,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_sequence *s),
-	TP_ARGS(s)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_sequence *s),
+	TP_ARGS(tgid, fd, s)
 );
 
 DEFINE_EVENT(v4l2_ctrl_mpeg2_pic_tmpl, v4l2_ctrl_mpeg2_picture,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_picture *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_picture *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 DEFINE_EVENT(v4l2_ctrl_mpeg2_quant_tmpl, v4l2_ctrl_mpeg2_quantisation,
-	TP_PROTO(const struct v4l2_ctrl_mpeg2_quantisation *q),
-	TP_ARGS(q)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_mpeg2_quantisation *q),
+	TP_ARGS(tgid, fd, q)
 );
 
 /* VP8 controls */
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__array(__u8, entropy_coeff_probs, 4 * 8 * 3 * V4L2_VP8_COEFF_PROB_CNT)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(tgid, fd, f),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__u8, entropy_coeff_probs, 4 * 8 * 3 * V4L2_VP8_COEFF_PROB_CNT)
 			 __array(__u8, entropy_y_mode_probs, 4)
 			 __array(__u8, entropy_uv_mode_probs, 3)
 			 __array(__u8, entropy_mv_probs, 2 * 19)),
-	TP_fast_assign(memcpy(__entry->entropy_coeff_probs, f->entropy.coeff_probs,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->entropy_coeff_probs, f->entropy.coeff_probs,
 			      sizeof(__entry->entropy_coeff_probs));
 		       memcpy(__entry->entropy_y_mode_probs, f->entropy.y_mode_probs,
 			      sizeof(__entry->entropy_y_mode_probs));
@@ -1915,10 +2073,12 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
 			      sizeof(__entry->entropy_uv_mode_probs));
 		       memcpy(__entry->entropy_mv_probs, f->entropy.mv_probs,
 			      sizeof(__entry->entropy_mv_probs));),
-	TP_printk("\nentropy.coeff_probs {%s}\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nentropy.coeff_probs {%s}\n"
 		  "entropy.y_mode_probs %s\n"
 		  "entropy.uv_mode_probs %s\n"
 		  "entropy.mv_probs {%s}",
+		  __entry->tgid, __entry->fd,
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
 				   __entry->entropy_coeff_probs,
 				   sizeof(__entry->entropy_coeff_probs),
@@ -1937,9 +2097,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_entropy_tmpl,
 )
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__array(__s8, segment_quant_update, 4)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(tgid, fd, f),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__s8, segment_quant_update, 4)
 			 __array(__s8, segment_lf_update, 4)
 			 __array(__u8, segment_segment_probs, 3)
 			 __field(__u32, segment_flags)
@@ -1974,7 +2136,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
 			 __field(__u64, golden_frame_ts)
 			 __field(__u64, alt_frame_ts)
 			 __field(__u64, flags)),
-	TP_fast_assign(memcpy(__entry->segment_quant_update, f->segment.quant_update,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->segment_quant_update, f->segment.quant_update,
 			      sizeof(__entry->segment_quant_update));
 		       memcpy(__entry->segment_lf_update, f->segment.lf_update,
 			      sizeof(__entry->segment_lf_update));
@@ -2015,7 +2179,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
 		       __entry->golden_frame_ts = f->golden_frame_ts;
 		       __entry->alt_frame_ts = f->alt_frame_ts;
 		       __entry->flags = f->flags;),
-	TP_printk("\nsegment.quant_update %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nsegment.quant_update %s\n"
 		  "segment.lf_update %s\n"
 		  "segment.segment_probs %s\n"
 		  "segment.flags %s\n"
@@ -2050,6 +2215,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
 		  "golden_frame_ts %llu\n"
 		  "alt_frame_ts %llu\n"
 		  "flags %s",
+		  __entry->tgid, __entry->fd,
 		  __print_array(__entry->segment_quant_update,
 				ARRAY_SIZE(__entry->segment_quant_update),
 				sizeof(__entry->segment_quant_update[0])),
@@ -2114,21 +2280,23 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp8_frame_tmpl,
 );
 
 DEFINE_EVENT(v4l2_ctrl_vp8_frame_tmpl, v4l2_ctrl_vp8_frame,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(tgid, fd, f)
 );
 
 DEFINE_EVENT(v4l2_ctrl_vp8_entropy_tmpl, v4l2_ctrl_vp8_entropy,
-	TP_PROTO(const struct v4l2_ctrl_vp8_frame *f),
-	TP_ARGS(f)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp8_frame *f),
+	TP_ARGS(tgid, fd, f)
 );
 
 /* VP9 controls */
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
-	TP_ARGS(f),
-	TP_STRUCT__entry(__array(__s8, lf_ref_deltas, 4)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_frame *f),
+	TP_ARGS(tgid, fd, f),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__s8, lf_ref_deltas, 4)
 			 __array(__s8, lf_mode_deltas, 2)
 			 __field(__u8, lf_level)
 			 __field(__u8, lf_sharpness)
@@ -2161,7 +2329,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 			 __field(__u8, tile_cols_log2)
 			 __field(__u8, tile_rows_log2)
 			 __field(__u8, reference_mode)),
-	TP_fast_assign(memcpy(__entry->lf_ref_deltas, f->lf.ref_deltas,
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->lf_ref_deltas, f->lf.ref_deltas,
 			      sizeof(__entry->lf_ref_deltas));
 		       memcpy(__entry->lf_mode_deltas, f->lf.mode_deltas,
 			      sizeof(__entry->lf_mode_deltas));
@@ -2200,7 +2370,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 		       __entry->tile_cols_log2 = f->tile_cols_log2;
 		       __entry->tile_rows_log2 = f->tile_rows_log2;
 		       __entry->reference_mode = f->reference_mode;),
-	TP_printk("\nlf.ref_deltas %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\nlf.ref_deltas %s\n"
 		  "lf.mode_deltas %s\n"
 		  "lf.level %u\n"
 		  "lf.sharpness %u\n"
@@ -2233,6 +2404,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 		  "tile_cols_log2 %u\n"
 		  "tile_rows_log_2 %u\n"
 		  "reference_mode %s\n",
+		  __entry->tgid, __entry->fd,
 		  __print_array(__entry->lf_ref_deltas,
 				ARRAY_SIZE(__entry->lf_ref_deltas),
 				sizeof(__entry->lf_ref_deltas[0])),
@@ -2313,9 +2485,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_frame_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h),
-	TP_STRUCT__entry(__field(__u8, tx_mode)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(tgid, fd, h),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __field(__u8, tx_mode)
 			 __array(__u8, tx8, 2 * 1)
 			 __array(__u8, tx16, 2 * 2)
 			 __array(__u8, tx32, 2 * 3)
@@ -2329,7 +2503,9 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 			 __array(__u8, y_mode, 4 * 9)
 			 __array(__u8, uv_mode, 10 * 9)
 			 __array(__u8, partition, 16 * 3)),
-	TP_fast_assign(__entry->tx_mode = h->tx_mode;
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       __entry->tx_mode = h->tx_mode;
 		       memcpy(__entry->tx8, h->tx8, sizeof(__entry->tx8));
 		       memcpy(__entry->tx16, h->tx16, sizeof(__entry->tx16));
 		       memcpy(__entry->tx32, h->tx32, sizeof(__entry->tx32));
@@ -2344,7 +2520,8 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 		       memcpy(__entry->y_mode, h->y_mode, sizeof(__entry->y_mode));
 		       memcpy(__entry->uv_mode, h->uv_mode, sizeof(__entry->uv_mode));
 		       memcpy(__entry->partition, h->partition, sizeof(__entry->partition));),
-	TP_printk("\ntx_mode %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\ntx_mode %s\n"
 		  "tx8 {%s}\n"
 		  "tx16 {%s}\n"
 		  "tx32 {%s}\n"
@@ -2358,6 +2535,7 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 		  "y_mode {%s}\n"
 		  "uv_mode {%s}\n"
 		  "partition {%s}\n",
+		  __entry->tgid, __entry->fd,
 		  __print_symbolic(__entry->tx_mode,
 		  {V4L2_VP9_TX_MODE_ONLY_4X4, "TX_MODE_ONLY_4X4"},
 		  {V4L2_VP9_TX_MODE_ALLOW_8X8, "TX_MODE_ALLOW_8X8"},
@@ -2416,11 +2594,17 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_hdr_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h),
-	TP_STRUCT__entry(__array(__u8, coef, 4 * 2 * 2 * 6 * 6 * 3)),
-	TP_fast_assign(memcpy(__entry->coef, h->coef, sizeof(__entry->coef));),
-	TP_printk("\n coef {%s}",
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(tgid, fd, h),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__u8, coef, 4 * 2 * 2 * 6 * 6 * 3)),
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->coef, h->coef, sizeof(__entry->coef));),
+	TP_printk("tgid = %u, fd = %u, "
+		  "\n coef {%s}",
+		  __entry->tgid, __entry->fd,
 		  __print_hex_dump("", DUMP_PREFIX_NONE, 32, 1,
 				   __entry->coef,
 				   sizeof(__entry->coef),
@@ -2429,9 +2613,11 @@ DECLARE_EVENT_CLASS(v4l2_ctrl_vp9_compressed_coef_tmpl,
 );
 
 DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
-	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
-	TP_ARGS(p),
-	TP_STRUCT__entry(__array(__u8, joint, 3)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_vp9_mv_probs *p),
+	TP_ARGS(tgid, fd, p),
+	TP_STRUCT__entry(__field(u32, tgid)
+			 __field(u32, fd)
+			 __array(__u8, joint, 3)
 			 __array(__u8, sign, 2)
 			 __array(__u8, classes, 2 * 10)
 			 __array(__u8, class0_bit, 2)
@@ -2440,7 +2626,9 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
 			 __array(__u8, fr, 2 * 3)
 			 __array(__u8, class0_hp, 2)
 			 __array(__u8, hp, 2)),
-	TP_fast_assign(memcpy(__entry->joint, p->joint, sizeof(__entry->joint));
+	TP_fast_assign(__entry->tgid = tgid;
+		       __entry->fd = fd;
+		       memcpy(__entry->joint, p->joint, sizeof(__entry->joint));
 		       memcpy(__entry->sign, p->sign, sizeof(__entry->sign));
 		       memcpy(__entry->classes, p->classes, sizeof(__entry->classes));
 		       memcpy(__entry->class0_bit, p->class0_bit, sizeof(__entry->class0_bit));
@@ -2449,7 +2637,8 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
 		       memcpy(__entry->fr, p->fr, sizeof(__entry->fr));
 		       memcpy(__entry->class0_hp, p->class0_hp, sizeof(__entry->class0_hp));
 		       memcpy(__entry->hp, p->hp, sizeof(__entry->hp));),
-	TP_printk("\n joint %s\n"
+	TP_printk("tgid = %u, fd = %u, "
+		  "\n joint %s\n"
 		  "sign %s\n"
 		  "classes {%s}\n"
 		  "class0_bit %s\n"
@@ -2458,6 +2647,7 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
 		  "fr {%s}\n"
 		  "class0_hp %s\n"
 		  "hp %s\n",
+		  __entry->tgid, __entry->fd,
 		  __print_array(__entry->joint,
 				ARRAY_SIZE(__entry->joint),
 				sizeof(__entry->joint[0])),
@@ -2493,24 +2683,24 @@ DECLARE_EVENT_CLASS(v4l2_vp9_mv_probs_tmpl,
 );
 
 DEFINE_EVENT(v4l2_ctrl_vp9_frame_tmpl, v4l2_ctrl_vp9_frame,
-	TP_PROTO(const struct v4l2_ctrl_vp9_frame *f),
-	TP_ARGS(f)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_frame *f),
+	TP_ARGS(tgid, fd, f)
 );
 
 DEFINE_EVENT(v4l2_ctrl_vp9_compressed_hdr_tmpl, v4l2_ctrl_vp9_compressed_hdr,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(tgid, fd, h)
 );
 
 DEFINE_EVENT(v4l2_ctrl_vp9_compressed_coef_tmpl, v4l2_ctrl_vp9_compressed_coeff,
-	TP_PROTO(const struct v4l2_ctrl_vp9_compressed_hdr *h),
-	TP_ARGS(h)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_ctrl_vp9_compressed_hdr *h),
+	TP_ARGS(tgid, fd, h)
 );
 
 
 DEFINE_EVENT(v4l2_vp9_mv_probs_tmpl, v4l2_vp9_mv_probs,
-	TP_PROTO(const struct v4l2_vp9_mv_probs *p),
-	TP_ARGS(p)
+	TP_PROTO(u32 tgid, u32 fd, const struct v4l2_vp9_mv_probs *p),
+	TP_ARGS(tgid, fd, p)
 );
 
 #endif /* if !defined(_TRACE_V4L2_CONTROLS_H_) || defined(TRACE_HEADER_MULTI_READ) */

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 5/9] media: Add missing types to v4l2_ctrl_ptr
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (3 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 4/9] media: Add tgid and fd to the v4l2-requests trace fields Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 6/9] media: Trace the stateless controls when set in v4l2-ctrls-core.c Detlev Casanova
                   ` (4 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

The v4l2_ctrl_ptr union contains pointers for all control types, but
v4l2_ctrl_hevc_decode_params and v4l2_ctrl_hevc_scaling_matrix are missing.

Add them.

Reviewed-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 include/media/v4l2-ctrls.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
index 327976b14d50..a2b4c96a9a6f 100644
--- a/include/media/v4l2-ctrls.h
+++ b/include/media/v4l2-ctrls.h
@@ -49,6 +49,8 @@ struct video_device;
  * @p_hevc_sps:			Pointer to an HEVC sequence parameter set structure.
  * @p_hevc_pps:			Pointer to an HEVC picture parameter set structure.
  * @p_hevc_slice_params:	Pointer to an HEVC slice parameters structure.
+ * @p_hevc_decode_params:	Pointer to an HEVC decode parameters structure.
+ * @p_hevc_scaling_matrix	Pointer to an HEVC scaling matrix structure.
  * @p_hdr10_cll:		Pointer to an HDR10 Content Light Level structure.
  * @p_hdr10_mastering:		Pointer to an HDR10 Mastering Display structure.
  * @p_area:			Pointer to an area.
@@ -81,6 +83,8 @@ union v4l2_ctrl_ptr {
 	struct v4l2_ctrl_hevc_sps *p_hevc_sps;
 	struct v4l2_ctrl_hevc_pps *p_hevc_pps;
 	struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
+	struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params;
+	struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix;
 	struct v4l2_ctrl_vp9_compressed_hdr *p_vp9_compressed_hdr_probs;
 	struct v4l2_ctrl_vp9_frame *p_vp9_frame;
 	struct v4l2_ctrl_hdr10_cll_info *p_hdr10_cll;

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 6/9] media: Trace the stateless controls when set in v4l2-ctrls-core.c
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (4 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 5/9] media: Add missing types to v4l2_ctrl_ptr Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 7/9] media: Add stream on/off traces and run them in the ioctl Detlev Casanova
                   ` (3 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

Also remove the trace from visl as the generic v4l2-requests traces can
now be used instead.

It allows all stateless drivers to inherit traceability, with just a small
overhead when disabled in userspace.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 drivers/media/test-drivers/visl/visl-dec.c |  74 -------------------
 drivers/media/v4l2-core/v4l2-ctrls-api.c   |  10 +++
 drivers/media/v4l2-core/v4l2-ctrls-core.c  | 114 +++++++++++++++++++++++++++++
 include/media/v4l2-ctrls.h                 |  15 ++++
 4 files changed, 139 insertions(+), 74 deletions(-)

diff --git a/drivers/media/test-drivers/visl/visl-dec.c b/drivers/media/test-drivers/visl/visl-dec.c
index 2a065a6249ad..9517830fb3e8 100644
--- a/drivers/media/test-drivers/visl/visl-dec.c
+++ b/drivers/media/test-drivers/visl/visl-dec.c
@@ -12,7 +12,6 @@
 #include <linux/workqueue.h>
 #include <media/v4l2-mem2mem.h>
 #include <media/tpg/v4l2-tpg.h>
-#include <trace/events/v4l2_controls.h>
 
 #define LAST_BUF_IDX (V4L2_AV1_REF_LAST_FRAME - V4L2_AV1_REF_LAST_FRAME)
 #define LAST2_BUF_IDX (V4L2_AV1_REF_LAST2_FRAME - V4L2_AV1_REF_LAST_FRAME)
@@ -486,78 +485,6 @@ static void visl_tpg_fill(struct visl_ctx *ctx, struct visl_run *run)
 	}
 }
 
-static void visl_trace_ctrls(struct visl_ctx *ctx, struct visl_run *run)
-{
-	int i;
-	struct v4l2_fh *fh = &ctx->fh;
-
-	switch (ctx->current_codec) {
-	default:
-	case VISL_CODEC_NONE:
-		break;
-	case VISL_CODEC_FWHT:
-		trace_v4l2_ctrl_fwht_params(fh->tgid, fh->fd, run->fwht.params);
-		break;
-	case VISL_CODEC_MPEG2:
-		trace_v4l2_ctrl_mpeg2_sequence(fh->tgid, fh->fd, run->mpeg2.seq);
-		trace_v4l2_ctrl_mpeg2_picture(fh->tgid, fh->fd, run->mpeg2.pic);
-		trace_v4l2_ctrl_mpeg2_quantisation(fh->tgid, fh->fd, run->mpeg2.quant);
-		break;
-	case VISL_CODEC_VP8:
-		trace_v4l2_ctrl_vp8_frame(fh->tgid, fh->fd, run->vp8.frame);
-		trace_v4l2_ctrl_vp8_entropy(fh->tgid, fh->fd, run->vp8.frame);
-		break;
-	case VISL_CODEC_VP9:
-		trace_v4l2_ctrl_vp9_frame(fh->tgid, fh->fd, run->vp9.frame);
-		trace_v4l2_ctrl_vp9_compressed_hdr(fh->tgid, fh->fd, run->vp9.probs);
-		trace_v4l2_ctrl_vp9_compressed_coeff(fh->tgid, fh->fd, run->vp9.probs);
-		trace_v4l2_vp9_mv_probs(fh->tgid, fh->fd, &run->vp9.probs->mv);
-		break;
-	case VISL_CODEC_H264:
-		trace_v4l2_ctrl_h264_sps(fh->tgid, fh->fd, run->h264.sps);
-		trace_v4l2_ctrl_h264_pps(fh->tgid, fh->fd, run->h264.pps);
-		trace_v4l2_ctrl_h264_scaling_matrix(fh->tgid, fh->fd, run->h264.sm);
-		trace_v4l2_ctrl_h264_slice_params(fh->tgid, fh->fd, run->h264.spram);
-
-		for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
-			trace_v4l2_h264_ref_pic_list0(fh->tgid, fh->fd,
-						      &run->h264.spram->ref_pic_list0[i], i);
-		for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)
-			trace_v4l2_h264_ref_pic_list1(fh->tgid, fh->fd,
-						      &run->h264.spram->ref_pic_list1[i], i);
-
-		trace_v4l2_ctrl_h264_decode_params(fh->tgid, fh->fd, run->h264.dpram);
-
-		for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++)
-			trace_v4l2_h264_dpb_entry(fh->tgid, fh->fd, &run->h264.dpram->dpb[i], i);
-
-		trace_v4l2_ctrl_h264_pred_weights(fh->tgid, fh->fd, run->h264.pwht);
-		break;
-	case VISL_CODEC_HEVC:
-		trace_v4l2_ctrl_hevc_sps(fh->tgid, fh->fd, run->hevc.sps);
-		trace_v4l2_ctrl_hevc_pps(fh->tgid, fh->fd, run->hevc.pps);
-		trace_v4l2_ctrl_hevc_slice_params(fh->tgid, fh->fd, run->hevc.spram);
-		trace_v4l2_ctrl_hevc_scaling_matrix(fh->tgid, fh->fd, run->hevc.sm);
-		trace_v4l2_ctrl_hevc_decode_params(fh->tgid, fh->fd, run->hevc.dpram);
-
-		for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++)
-			trace_v4l2_hevc_dpb_entry(fh->tgid, fh->fd, &run->hevc.dpram->dpb[i]);
-
-
-		trace_v4l2_hevc_pred_weight_table(fh->tgid, fh->fd,
-						  &run->hevc.spram->pred_weight_table);
-		trace_v4l2_ctrl_hevc_ext_sps_lt_rps(fh->tgid, fh->fd, run->hevc.rps_lt);
-		trace_v4l2_ctrl_hevc_ext_sps_st_rps(fh->tgid, fh->fd, run->hevc.rps_st);
-		break;
-	case VISL_CODEC_AV1:
-		trace_v4l2_ctrl_av1_sequence(fh->tgid, fh->fd, run->av1.seq);
-		trace_v4l2_ctrl_av1_frame(fh->tgid, fh->fd, run->av1.frame);
-		trace_v4l2_ctrl_av1_film_grain(fh->tgid, fh->fd, run->av1.grain);
-		trace_v4l2_ctrl_av1_tile_group_entry(fh->tgid, fh->fd, run->av1.tge);
-		break;
-	}
-}
-
 void visl_device_run(void *priv)
 {
 	struct visl_ctx *ctx = priv;
@@ -634,7 +561,6 @@ void visl_device_run(void *priv)
 		      run.dst->sequence, run.dst->vb2_buf.timestamp);
 
 	visl_tpg_fill(ctx, &run);
-	visl_trace_ctrls(ctx, &run);
 
 	if (bitstream_trace_frame_start > -1 &&
 	    run.dst->sequence >= bitstream_trace_frame_start &&
diff --git a/drivers/media/v4l2-core/v4l2-ctrls-api.c b/drivers/media/v4l2-core/v4l2-ctrls-api.c
index 93d8d4012d0f..c44578828b21 100644
--- a/drivers/media/v4l2-core/v4l2-ctrls-api.c
+++ b/drivers/media/v4l2-core/v4l2-ctrls-api.c
@@ -523,6 +523,12 @@ int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
 }
 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
 
+static void trace_ext_ctrl(struct v4l2_fh *fh, const struct v4l2_ctrl *ctrl)
+{
+	if (ctrl->type_ops->trace)
+		ctrl->type_ops->trace(fh, ctrl, ctrl->p_cur);
+}
+
 /* Validate a new control */
 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
 {
@@ -711,6 +717,10 @@ int try_set_ext_ctrls_common(struct v4l2_fh *fh,
 				idx = helpers[idx].next;
 			} while (!ret && idx);
 		}
+
+		if (set)
+			trace_ext_ctrl(fh, master);
+
 		v4l2_ctrl_unlock(master);
 	}
 
diff --git a/drivers/media/v4l2-core/v4l2-ctrls-core.c b/drivers/media/v4l2-core/v4l2-ctrls-core.c
index 6b375720e395..d8a8dc7896c5 100644
--- a/drivers/media/v4l2-core/v4l2-ctrls-core.c
+++ b/drivers/media/v4l2-core/v4l2-ctrls-core.c
@@ -10,8 +10,11 @@
 #include <linux/slab.h>
 #include <media/v4l2-ctrls.h>
 #include <media/v4l2-event.h>
+#include <media/v4l2-fh.h>
 #include <media/v4l2-fwnode.h>
 
+#include <trace/events/v4l2_controls.h>
+
 #include "v4l2-ctrls-priv.h"
 
 static const union v4l2_ctrl_ptr ptr_null;
@@ -1462,12 +1465,123 @@ int v4l2_ctrl_type_op_validate(const struct v4l2_ctrl *ctrl,
 }
 EXPORT_SYMBOL(v4l2_ctrl_type_op_validate);
 
+void v4l2_ctrl_type_op_trace(const struct v4l2_fh *fh,
+				    const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr)
+{
+	int i = 0;
+
+	switch ((u32)ctrl->type) {
+	case V4L2_CTRL_TYPE_FWHT_PARAMS:
+		trace_v4l2_ctrl_fwht_params(fh->tgid, fh->fd, ptr.p_fwht_params);
+		break;
+	case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
+		trace_v4l2_ctrl_mpeg2_sequence(fh->tgid, fh->fd, ptr.p_mpeg2_sequence);
+		break;
+	case V4L2_CTRL_TYPE_MPEG2_PICTURE:
+		trace_v4l2_ctrl_mpeg2_picture(fh->tgid, fh->fd, ptr.p_mpeg2_picture);
+		break;
+	case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
+		trace_v4l2_ctrl_mpeg2_quantisation(fh->tgid, fh->fd, ptr.p_mpeg2_quantisation);
+		break;
+	case V4L2_CTRL_TYPE_VP8_FRAME:
+		trace_v4l2_ctrl_vp8_frame(fh->tgid, fh->fd, ptr.p_vp8_frame);
+		trace_v4l2_ctrl_vp8_entropy(fh->tgid, fh->fd, ptr.p_vp8_frame);
+		break;
+	case V4L2_CTRL_TYPE_VP9_FRAME:
+		trace_v4l2_ctrl_vp9_frame(fh->tgid, fh->fd, ptr.p_vp9_frame);
+		break;
+	case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
+		trace_v4l2_ctrl_vp9_compressed_hdr(fh->tgid, fh->fd,
+						   ptr.p_vp9_compressed_hdr_probs);
+		trace_v4l2_ctrl_vp9_compressed_coeff(fh->tgid, fh->fd,
+						     ptr.p_vp9_compressed_hdr_probs);
+		trace_v4l2_vp9_mv_probs(fh->tgid, fh->fd, &ptr.p_vp9_compressed_hdr_probs->mv);
+		break;
+	case V4L2_CTRL_TYPE_H264_SPS:
+		trace_v4l2_ctrl_h264_sps(fh->tgid, fh->fd, ptr.p_h264_sps);
+		break;
+	case V4L2_CTRL_TYPE_H264_PPS:
+		trace_v4l2_ctrl_h264_pps(fh->tgid, fh->fd, ptr.p_h264_pps);
+		break;
+	case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
+		trace_v4l2_ctrl_h264_scaling_matrix(fh->tgid, fh->fd, ptr.p_h264_scaling_matrix);
+		break;
+	case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
+	{
+		struct v4l2_ctrl_h264_slice_params *sp = ptr.p_h264_slice_params;
+
+		trace_v4l2_ctrl_h264_slice_params(fh->tgid, fh->fd, sp);
+
+		for (i = 0; i < ARRAY_SIZE(sp->ref_pic_list0); i++)
+			trace_v4l2_h264_ref_pic_list0(fh->tgid, fh->fd, &sp->ref_pic_list0[i], i);
+		for (i = 0; i < ARRAY_SIZE(sp->ref_pic_list1); i++)
+			trace_v4l2_h264_ref_pic_list1(fh->tgid, fh->fd, &sp->ref_pic_list1[i], i);
+
+		break;
+	}
+	case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
+	{
+		struct v4l2_ctrl_h264_decode_params *dp = ptr.p_h264_decode_params;
+
+		trace_v4l2_ctrl_h264_decode_params(fh->tgid, fh->fd, dp);
+
+		for (i = 0; i < ARRAY_SIZE(dp->dpb); i++)
+			trace_v4l2_h264_dpb_entry(fh->tgid, fh->fd, &dp->dpb[i], i);
+
+		break;
+	}
+	case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
+		trace_v4l2_ctrl_h264_pred_weights(fh->tgid, fh->fd, ptr.p_h264_pred_weights);
+		break;
+	case V4L2_CTRL_TYPE_HEVC_SPS:
+		trace_v4l2_ctrl_hevc_sps(fh->tgid, fh->fd, ptr.p_hevc_sps);
+		break;
+	case V4L2_CTRL_TYPE_HEVC_PPS:
+		trace_v4l2_ctrl_hevc_pps(fh->tgid, fh->fd, ptr.p_hevc_pps);
+		break;
+	case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
+		trace_v4l2_ctrl_hevc_slice_params(fh->tgid, fh->fd, ptr.p_hevc_slice_params);
+		trace_v4l2_hevc_pred_weight_table(fh->tgid, fh->fd,
+						  &ptr.p_hevc_slice_params->pred_weight_table);
+		break;
+	case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
+		trace_v4l2_ctrl_hevc_scaling_matrix(fh->tgid, fh->fd, ptr.p_hevc_scaling_matrix);
+		break;
+	case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
+	{
+		struct v4l2_ctrl_hevc_decode_params *dp = ptr.p_hevc_decode_params;
+
+		trace_v4l2_ctrl_hevc_decode_params(fh->tgid, fh->fd, dp);
+
+		for (i = 0; i < ARRAY_SIZE(dp->dpb); i++)
+			trace_v4l2_hevc_dpb_entry(fh->tgid, fh->fd, &dp->dpb[i]);
+
+		break;
+	}
+	case V4L2_CTRL_TYPE_AV1_SEQUENCE:
+		trace_v4l2_ctrl_av1_sequence(fh->tgid, fh->fd, ptr.p_av1_sequence);
+		break;
+	case V4L2_CTRL_TYPE_AV1_FRAME:
+		trace_v4l2_ctrl_av1_frame(fh->tgid, fh->fd, ptr.p_av1_frame);
+		break;
+	case V4L2_CTRL_TYPE_AV1_FILM_GRAIN:
+		trace_v4l2_ctrl_av1_film_grain(fh->tgid, fh->fd, ptr.p_av1_film_grain);
+		break;
+	case V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY:
+		trace_v4l2_ctrl_av1_tile_group_entry(fh->tgid, fh->fd, ptr.p_av1_tile_group_entry);
+		break;
+	}
+
+}
+EXPORT_SYMBOL(v4l2_ctrl_type_op_trace);
+
 static const struct v4l2_ctrl_type_ops std_type_ops = {
 	.equal = v4l2_ctrl_type_op_equal,
 	.init = v4l2_ctrl_type_op_init,
 	.minimum = v4l2_ctrl_type_op_minimum,
 	.maximum = v4l2_ctrl_type_op_maximum,
 	.log = v4l2_ctrl_type_op_log,
+	.trace = v4l2_ctrl_type_op_trace,
 	.validate = v4l2_ctrl_type_op_validate,
 };
 
diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
index a2b4c96a9a6f..57c4bb999b7b 100644
--- a/include/media/v4l2-ctrls.h
+++ b/include/media/v4l2-ctrls.h
@@ -140,6 +140,7 @@ struct v4l2_ctrl_ops {
  * @minimum: set the value to the minimum value of the control.
  * @maximum: set the value to the maximum value of the control.
  * @log: log the value.
+ * @trace: trace the value of the control with Ftrace.
  * @validate: validate the value for ctrl->new_elems array elements.
  *	Return 0 on success and a negative value otherwise.
  */
@@ -153,6 +154,8 @@ struct v4l2_ctrl_type_ops {
 	void (*maximum)(const struct v4l2_ctrl *ctrl, u32 idx,
 			union v4l2_ctrl_ptr ptr);
 	void (*log)(const struct v4l2_ctrl *ctrl);
+	void (*trace)(const struct v4l2_fh *fh,
+		      const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
 	int (*validate)(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
 };
 
@@ -1627,6 +1630,18 @@ void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
  */
 void v4l2_ctrl_type_op_log(const struct v4l2_ctrl *ctrl);
 
+/**
+ * v4l2_ctrl_type_op_trace - Default v4l2_ctrl_type_ops trace callback.
+ *
+ * @fh: The v4l2_fh of the current context.
+ * @ctrl: The v4l2_ctrl pointer.
+ * @ptr: The v4l2 control value.
+ *
+ * Return: void
+ */
+void v4l2_ctrl_type_op_trace(const struct v4l2_fh *fh,
+			     const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
+
 /**
  * v4l2_ctrl_type_op_validate - Default v4l2_ctrl_type_ops validate callback.
  *

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 7/9] media: Add stream on/off traces and run them in the ioctl
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (5 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 6/9] media: Trace the stateless controls when set in v4l2-ctrls-core.c Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 8/9] media: Add HW run/done trace events Detlev Casanova
                   ` (2 subsequent siblings)
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

This will automatically add stream on/off tracing for all v4l2 drivers.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 drivers/media/v4l2-core/v4l2-ioctl.c | 20 +++++++++++++++++--
 include/trace/events/v4l2.h          | 37 ++++++++++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index c8746a1637f5..b09489baff3e 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -1963,13 +1963,29 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 static int v4l_streamon(const struct v4l2_ioctl_ops *ops, struct file *file,
 			void *arg)
 {
-	return ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
+	struct v4l2_fh *fh = file_to_v4l2_fh(file);
+	int err;
+
+	err = ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
+
+	if (!err)
+		trace_v4l2_streamon(fh->tgid, fh->fd);
+
+	return err;
 }
 
 static int v4l_streamoff(const struct v4l2_ioctl_ops *ops, struct file *file,
 			 void *arg)
 {
-	return ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
+	struct v4l2_fh *fh = file_to_v4l2_fh(file);
+	int err;
+
+	err = ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
+
+	if (!err)
+		trace_v4l2_streamoff(fh->tgid, fh->fd);
+
+	return err;
 }
 
 static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
diff --git a/include/trace/events/v4l2.h b/include/trace/events/v4l2.h
index 248bc09bfc99..e5b80aeecc30 100644
--- a/include/trace/events/v4l2.h
+++ b/include/trace/events/v4l2.h
@@ -262,6 +262,43 @@ DEFINE_EVENT(vb2_v4l2_event_class, vb2_v4l2_qbuf,
 	TP_ARGS(q, vb)
 );
 
+
+/* Events for stream on/off.
+ *
+ * These events will be fired every time userspace starts or stops a stream.
+ * tgid and fd are used to identify the process that opened the video device.
+ *
+ * Note that this even can be fired multiple times for a given tgid/fd pair.
+ * E.g.: mem2mem drivers expect stream on/off on both output and capture queues.
+ */
+DECLARE_EVENT_CLASS(v4l2_stream_class,
+	TP_PROTO(u32 tgid, u32 fd),
+	TP_ARGS(tgid, fd),
+
+	TP_STRUCT__entry(
+		__field(u32, tgid)
+		__field(u32, fd)
+	),
+
+	TP_fast_assign(
+		__entry->tgid = tgid;
+		__entry->fd = fd;
+	),
+
+	TP_printk("tgid = %u, fd = %u",
+		  __entry->tgid, __entry->fd)
+);
+
+DEFINE_EVENT(v4l2_stream_class, v4l2_streamon,
+	TP_PROTO(u32 tgid, u32 fd),
+	TP_ARGS(tgid, fd)
+);
+
+DEFINE_EVENT(v4l2_stream_class, v4l2_streamoff,
+	TP_PROTO(u32 tgid, u32 fd),
+	TP_ARGS(tgid, fd)
+);
+
 #endif /* if !defined(_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */
 
 /* This part must be outside protection */

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 8/9] media: Add HW run/done trace events
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (6 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 7/9] media: Add stream on/off traces and run them in the ioctl Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-06-10 14:33 ` [PATCH v2 9/9] media: hantro: Add v4l2_hw run/done traces Detlev Casanova
  2026-11-17 22:08 ` [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Nicolas Dufresne
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

The events can be fired by drivers when the hardware is run and when it
is done.
That can be used by userspace tracers to see HW performance and usage.

The hw_done event allows setting the number of clock cycles the HW needed
to do the work, to help tools evaluate performances.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 drivers/media/v4l2-core/v4l2-trace.c |  3 +++
 include/trace/events/v4l2.h          | 40 ++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/drivers/media/v4l2-core/v4l2-trace.c b/drivers/media/v4l2-core/v4l2-trace.c
index 183d5ecb49c5..59cf6f8807ac 100644
--- a/drivers/media/v4l2-core/v4l2-trace.c
+++ b/drivers/media/v4l2-core/v4l2-trace.c
@@ -12,6 +12,9 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_buf_queue);
 EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_dqbuf);
 EXPORT_TRACEPOINT_SYMBOL_GPL(vb2_v4l2_qbuf);
 
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hw_run);
+EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_hw_done);
+
 /* Export AV1 controls */
 EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_sequence);
 EXPORT_TRACEPOINT_SYMBOL_GPL(v4l2_ctrl_av1_frame);
diff --git a/include/trace/events/v4l2.h b/include/trace/events/v4l2.h
index e5b80aeecc30..6f1bbb085cb0 100644
--- a/include/trace/events/v4l2.h
+++ b/include/trace/events/v4l2.h
@@ -299,6 +299,46 @@ DEFINE_EVENT(v4l2_stream_class, v4l2_streamoff,
 	TP_ARGS(tgid, fd)
 );
 
+
+/* Events for hardware run/done.
+ *
+ * These events will be fired respectively when the hardware is run (v4l2_hw_run) and done
+ * (v4l2_hw_done).
+ * As for other events, tgid and fd are used to identify the process that opened the video device.
+ *
+ * The v4l2_hw_done event also includes the number of hardware cycles taken by the hardware to
+ * process the command.
+ */
+DEFINE_EVENT(v4l2_stream_class, v4l2_hw_run,
+	TP_PROTO(u32 tgid, u32 fd),
+	TP_ARGS(tgid, fd)
+);
+
+DECLARE_EVENT_CLASS(v4l2_hw_done_class,
+	TP_PROTO(u32 tgid, u32 fd, u32 hw_cycles),
+	TP_ARGS(tgid, fd, hw_cycles),
+
+	TP_STRUCT__entry(
+		__field(u32, tgid)
+		__field(u32, fd)
+		__field(u32, hw_cycles)
+	),
+
+	TP_fast_assign(
+		__entry->tgid = tgid;
+		__entry->fd = fd;
+		__entry->hw_cycles = hw_cycles;
+	),
+
+	TP_printk("tgid = %u, fd = %u, hw_cycles = %u",
+		  __entry->tgid, __entry->fd, __entry->hw_cycles)
+);
+
+DEFINE_EVENT(v4l2_hw_done_class, v4l2_hw_done,
+	TP_PROTO(u32 tgid, u32 fd, u32 hw_cycles),
+	TP_ARGS(tgid, fd, hw_cycles)
+);
+
 #endif /* if !defined(_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */
 
 /* This part must be outside protection */

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* [PATCH v2 9/9] media: hantro: Add v4l2_hw run/done traces
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (7 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 8/9] media: Add HW run/done trace events Detlev Casanova
@ 2026-06-10 14:33 ` Detlev Casanova
  2026-11-17 22:08 ` [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Nicolas Dufresne
  9 siblings, 0 replies; 11+ messages in thread
From: Detlev Casanova @ 2026-06-10 14:33 UTC (permalink / raw)
  To: Daniel Almeida, Mauro Carvalho Chehab, Steven Rostedt,
	Masami Hiramatsu, Mathieu Desnoyers, Nicolas Dufresne,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel, Detlev Casanova

Add the trace calls as well as retrieving the number of clock cycles for
the rockchip_vpu core.

Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
---
 drivers/media/platform/verisilicon/hantro.h               |  1 +
 drivers/media/platform/verisilicon/hantro_drv.c           | 10 ++++++++++
 drivers/media/platform/verisilicon/rockchip_vpu981_regs.h |  1 +
 drivers/media/platform/verisilicon/rockchip_vpu_hw.c      |  4 ++++
 4 files changed, 16 insertions(+)

diff --git a/drivers/media/platform/verisilicon/hantro.h b/drivers/media/platform/verisilicon/hantro.h
index 0353de154a1e..d5cddc783688 100644
--- a/drivers/media/platform/verisilicon/hantro.h
+++ b/drivers/media/platform/verisilicon/hantro.h
@@ -253,6 +253,7 @@ struct hantro_ctx {
 
 	u32 sequence_cap;
 	u32 sequence_out;
+	u32 hw_cycles;
 
 	const struct hantro_fmt *vpu_src_fmt;
 	struct v4l2_pix_format_mplane src_fmt;
diff --git a/drivers/media/platform/verisilicon/hantro_drv.c b/drivers/media/platform/verisilicon/hantro_drv.c
index 2e81877f640f..32855b14e0f1 100644
--- a/drivers/media/platform/verisilicon/hantro_drv.c
+++ b/drivers/media/platform/verisilicon/hantro_drv.c
@@ -25,6 +25,8 @@
 #include <media/videobuf2-core.h>
 #include <media/videobuf2-vmalloc.h>
 
+#include <trace/events/v4l2.h>
+
 #include "hantro_v4l2.h"
 #include "hantro.h"
 #include "hantro_hw.h"
@@ -103,6 +105,9 @@ void hantro_irq_done(struct hantro_dev *vpu,
 	struct hantro_ctx *ctx =
 		v4l2_m2m_get_curr_priv(vpu->m2m_dev);
 
+	if (ctx)
+		trace_v4l2_hw_done(ctx->fh.tgid, ctx->fh.fd, ctx->hw_cycles);
+
 	/*
 	 * If cancel_delayed_work returns false
 	 * the timeout expired. The watchdog is running,
@@ -125,6 +130,9 @@ void hantro_watchdog(struct work_struct *work)
 	ctx = v4l2_m2m_get_curr_priv(vpu->m2m_dev);
 	if (ctx) {
 		vpu_err("frame processing timed out!\n");
+
+		trace_v4l2_hw_done(ctx->fh.tgid, ctx->fh.fd, ctx->hw_cycles);
+
 		if (ctx->codec_ops->reset)
 			ctx->codec_ops->reset(ctx);
 		hantro_job_finish(vpu, ctx, VB2_BUF_STATE_ERROR);
@@ -189,6 +197,8 @@ static void device_run(void *priv)
 	if (ctx->codec_ops->run(ctx))
 		goto err_cancel_job;
 
+	trace_v4l2_hw_run(ctx->fh.tgid, ctx->fh.fd);
+
 	return;
 
 err_cancel_job:
diff --git a/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h b/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h
index e4008da64f19..96b85470208b 100644
--- a/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h
+++ b/drivers/media/platform/verisilicon/rockchip_vpu981_regs.h
@@ -451,6 +451,7 @@
 #define av1_pp0_dup_ver			AV1_DEC_REG(394, 16, 0xff)
 #define av1_pp0_dup_hor			AV1_DEC_REG(394, 24, 0xff)
 
+#define AV1_CYCLE_COUNT			(AV1_SWREG(63))
 #define AV1_TILE_OUT_LU			(AV1_SWREG(65))
 #define AV1_REFERENCE_Y(i)		(AV1_SWREG(67) + ((i) * 0x8))
 #define AV1_SEGMENTATION		(AV1_SWREG(81))
diff --git a/drivers/media/platform/verisilicon/rockchip_vpu_hw.c b/drivers/media/platform/verisilicon/rockchip_vpu_hw.c
index 02673be9878e..f959151b6645 100644
--- a/drivers/media/platform/verisilicon/rockchip_vpu_hw.c
+++ b/drivers/media/platform/verisilicon/rockchip_vpu_hw.c
@@ -424,6 +424,8 @@ static irqreturn_t rk3588_vpu981_irq(int irq, void *dev_id)
 {
 	struct hantro_dev *vpu = dev_id;
 	enum vb2_buffer_state state;
+	struct hantro_ctx *ctx =
+		v4l2_m2m_get_curr_priv(vpu->m2m_dev);
 	u32 status;
 
 	status = vdpu_read(vpu, AV1_REG_INTERRUPT);
@@ -433,6 +435,8 @@ static irqreturn_t rk3588_vpu981_irq(int irq, void *dev_id)
 	vdpu_write(vpu, 0, AV1_REG_INTERRUPT);
 	vdpu_write(vpu, AV1_REG_CONFIG_DEC_CLK_GATE_E, AV1_REG_CONFIG);
 
+	ctx->hw_cycles = vdpu_read(vpu, AV1_CYCLE_COUNT);
+
 	hantro_irq_done(vpu, state);
 
 	return IRQ_HANDLED;

-- 
2.54.0


^ permalink raw reply related	[flat|nested] 11+ messages in thread

* Re: [PATCH v2 0/9] v4l2: Add tracing for stateless codecs
  2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
                   ` (8 preceding siblings ...)
  2026-06-10 14:33 ` [PATCH v2 9/9] media: hantro: Add v4l2_hw run/done traces Detlev Casanova
@ 2026-11-17 22:08 ` Nicolas Dufresne
  9 siblings, 0 replies; 11+ messages in thread
From: Nicolas Dufresne @ 2026-11-17 22:08 UTC (permalink / raw)
  To: Detlev Casanova, Daniel Almeida, Mauro Carvalho Chehab,
	Steven Rostedt, Masami Hiramatsu, Mathieu Desnoyers,
	Benjamin Gaignard, Philipp Zabel, Heiko Stuebner
  Cc: linux-kernel, linux-media, linux-trace-kernel, linux-rockchip,
	linux-arm-kernel, kernel

[-- Attachment #1: Type: text/plain, Size: 4311 bytes --]

Hi,

Le mercredi 10 juin 2026 à 10:33 -0400, Detlev Casanova a écrit :
> Hi !
> 
> This patchset aims to improve codec event tracing in v4l2.
> 
> The traces added in visl by Daniel Almeida are moved to the global trace
> events.
> They are adapted to trace each each field separately and not just the
> whole struct so that userspace can filter on different fields and
> libraries like libtracefs and libtraceevent can be used to list the
> fields instead of parsing the trace printk's.
> 
> The trace event templates are also reworked to avoid long lines, but
> quoted string splits are kept as they don't cut words.
> 
> To each trace event are also added a tgid and fd fields, helping
> userspace track different decoding sessions (contexts) based on the given
> file descriptor used by the given process id.
> 
> Also for better tracking, stream on and stream off events are added as
> well as HW run and HW done events to track decoder core usage.
> 
> The main focus is to be able to generate perfetto traces to show VPU usage,
> a perfetto producer using this can be found at [1] (it will be renamed to
> match the more generic approach than hantro).
> Other controls can be traced later as well, this patch set only focuses on
> mem2mem type drivers.

This is getting old, can you rebase and fix all the checkpatch and smatch issue.
There might be some build issues too?

https://gitlab.freedesktop.org/linux-media/users/patchwork/-/pipelines/1683571/

cheers,
Nicolas

> 
> [1]:
> https://gitlab.collabora.com/detlev/hantro-perf/-/tree/hantro-improved-info
> 
> Changes since v1:
> - Don't modify the printk format
> - Trace all fields of the structs instead of the whole struct as a buffer
> - Remove fdinfo patches (they will come in another patch set)
> - Fix long lines
> - Rename v4l2_requests.h trace header to v4l2_controls.h
> - Add basic documentation
> 
> Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
> ---
> Detlev Casanova (9):
>       media: Move visl traces to v4l2-core
>       media: Map each struct field to its own trace field
>       media: Add tgid and fd fields in v4l2_fh struct
>       media: Add tgid and fd to the v4l2-requests trace fields
>       media: Add missing types to v4l2_ctrl_ptr
>       media: Trace the stateless controls when set in v4l2-ctrls-core.c
>       media: Add stream on/off traces and run them in the ioctl
>       media: Add HW run/done trace events
>       media: hantro: Add v4l2_hw run/done traces
> 
>  drivers/media/platform/verisilicon/hantro.h        |    1 +
>  drivers/media/platform/verisilicon/hantro_drv.c    |   10 +
>  .../platform/verisilicon/rockchip_vpu981_regs.h    |    1 +
>  .../media/platform/verisilicon/rockchip_vpu_hw.c   |    4 +
>  drivers/media/test-drivers/visl/Makefile           |    2 +-
>  drivers/media/test-drivers/visl/visl-dec.c         |   76 -
>  drivers/media/test-drivers/visl/visl-trace-av1.h   |  314 ---
>  drivers/media/test-drivers/visl/visl-trace-fwht.h  |   66 -
>  drivers/media/test-drivers/visl/visl-trace-h264.h  |  349 ---
>  drivers/media/test-drivers/visl/visl-trace-hevc.h  |  464 ----
>  drivers/media/test-drivers/visl/visl-trace-mpeg2.h |   99 -
>  .../media/test-drivers/visl/visl-trace-points.c    |   11 -
>  drivers/media/test-drivers/visl/visl-trace-vp8.h   |  156 --
>  drivers/media/test-drivers/visl/visl-trace-vp9.h   |  292 ---
>  drivers/media/v4l2-core/v4l2-ctrls-api.c           |   10 +
>  drivers/media/v4l2-core/v4l2-ctrls-core.c          |  114 +
>  drivers/media/v4l2-core/v4l2-fh.c                  |    1 +
>  drivers/media/v4l2-core/v4l2-ioctl.c               |   37 +-
>  drivers/media/v4l2-core/v4l2-trace.c               |   48 +
>  include/media/v4l2-ctrls.h                         |   19 +
>  include/media/v4l2-fh.h                            |    4 +
>  include/trace/events/v4l2.h                        |   77 +
>  include/trace/events/v4l2_controls.h               | 2708 ++++++++++++++++++++
>  23 files changed, 3033 insertions(+), 1830 deletions(-)
> ---
> base-commit: acb7500801e98639f6d8c2d796ed9f64cba83d3a
> change-id: 20260608-v4l2-add-ftrace-aec6e7f60a6c
> 
> Best regards,
> --  
> Detlev Casanova <detlev.casanova@collabora.com>
> 

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

^ permalink raw reply	[flat|nested] 11+ messages in thread

end of thread, other threads:[~2026-11-17 22:08 UTC | newest]

Thread overview: 11+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-06-10 14:33 [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 1/9] media: Move visl traces to v4l2-core Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 2/9] media: Map each struct field to its own trace field Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 3/9] media: Add tgid and fd fields in v4l2_fh struct Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 4/9] media: Add tgid and fd to the v4l2-requests trace fields Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 5/9] media: Add missing types to v4l2_ctrl_ptr Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 6/9] media: Trace the stateless controls when set in v4l2-ctrls-core.c Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 7/9] media: Add stream on/off traces and run them in the ioctl Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 8/9] media: Add HW run/done trace events Detlev Casanova
2026-06-10 14:33 ` [PATCH v2 9/9] media: hantro: Add v4l2_hw run/done traces Detlev Casanova
2026-11-17 22:08 ` [PATCH v2 0/9] v4l2: Add tracing for stateless codecs Nicolas Dufresne

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox