[PATCH v3 4/8] media: iris: add VPU5x hardware ops

From: Wangao Wang

Date: Wed Nov 18 2026 - 04:42:12 EST


The Hawi SoC uses the VPU5x generation of the Iris video hardware, which
requires handling for two new power domains — mm-int for the internal
memory interconnect and cx-int for the CX domain AXI interface — as well
as additional generation-specific clocks. Without a VPU5x vpu_ops
implementation the Iris driver cannot power on or off the hardware on
Hawi.

Move the shared idle and core power status definitions to the common
register header so they can be used by both VPU4x and VPU5x code.

Signed-off-by: Wangao Wang <wangao.wang@xxxxxxxxxxxxxxxx>
---
drivers/media/platform/qcom/iris/Makefile | 1 +
drivers/media/platform/qcom/iris/iris_core.h | 4 +
drivers/media/platform/qcom/iris/iris_vpu5x.c | 448 +++++++++++++++++++++
drivers/media/platform/qcom/iris/iris_vpu_common.h | 1 +
4 files changed, 454 insertions(+)

diff --git a/drivers/media/platform/qcom/iris/Makefile b/drivers/media/platform/qcom/iris/Makefile
index bbd1f724963e66d45d9b52e5158c593f4061fd95..faaebea4a9afd9620c31fb9daeb8b4b500ecee82 100644
--- a/drivers/media/platform/qcom/iris/Makefile
+++ b/drivers/media/platform/qcom/iris/Makefile
@@ -27,6 +27,7 @@ qcom-iris-objs += iris_buffer.o \
iris_vpu2.o \
iris_vpu3x.o \
iris_vpu4x.o \
+ iris_vpu5x.o \
iris_vpu_ar50lt.o \
iris_vpu_buffer.o \
iris_vpu_common.o \
diff --git a/drivers/media/platform/qcom/iris/iris_core.h b/drivers/media/platform/qcom/iris/iris_core.h
index 5267d4be84902d655418479367e115536329698f..e6a883adf04bd086008f8b48bb880316f70da92c 100644
--- a/drivers/media/platform/qcom/iris/iris_core.h
+++ b/drivers/media/platform/qcom/iris/iris_core.h
@@ -63,6 +63,8 @@ struct qcom_ubwc_cfg_data;
* @vcodec_vpp0: power domain and clocks for the vcodec VPP0
* @vcodec_vpp1: power domain and clocks for the vcodec VPP1
* @apv: power domain and clocks for the APV hardware block
+ * @mm_int: power domain and clocks for the MM interconnect block
+ * @cx_int: power domain and clocks for the CX interconnect block
* @opp_pmdomain_tbl: table of opp power domains
* @resets: table of iris reset clocks
* @controller_resets: table of controller reset clocks
@@ -111,6 +113,8 @@ struct iris_core {
struct iris_power_domain *vcodec_vpp0;
struct iris_power_domain *vcodec_vpp1;
struct iris_power_domain *apv;
+ struct iris_power_domain *mm_int;
+ struct iris_power_domain *cx_int;
struct dev_pm_domain_list *opp_pmdomain_tbl;
struct reset_control_bulk_data *resets;
struct reset_control_bulk_data *controller_resets;
diff --git a/drivers/media/platform/qcom/iris/iris_vpu5x.c b/drivers/media/platform/qcom/iris/iris_vpu5x.c
new file mode 100644
index 0000000000000000000000000000000000000000..7a4ed4b3a81dbf8ddd446411ca6114c675d57102
--- /dev/null
+++ b/drivers/media/platform/qcom/iris/iris_vpu5x.c
@@ -0,0 +1,448 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ */
+
+#include <linux/iopoll.h>
+#include <linux/pm_opp.h>
+#include <linux/reset.h>
+
+#include "iris_instance.h"
+#include "iris_vpu_common.h"
+#include "iris_vpu_register_defines.h"
+
+/*
+ * iris5 specific register defines.
+ * Many base offsets are shared with prior generations:
+ * WRAPPER_BASE_OFFS = 0x000B0000
+ * AON_BASE_OFFS = 0x000E0000
+ * AON_MVP_NOC_RESET = 0x0001F000
+ * CPU_BASE_OFFS = 0x000A0000
+ */
+
+#define WRAPPER_MVP_NOC_LPI_CONTROL (WRAPPER_BASE_OFFS + 0x110)
+#define WRAPPER_MVP_NOC_LPI_STATUS (WRAPPER_BASE_OFFS + 0x114)
+#define WRAPPER_MVP_NOC_CX_LPI_CONTROL (WRAPPER_BASE_OFFS + 0x118)
+#define WRAPPER_MVP_NOC_CX_LPI_STATUS (WRAPPER_BASE_OFFS + 0x11C)
+
+#define AON_WRAPPER_MVP_NOC_ARCG_CONTROL (AON_BASE_OFFS + 0x10)
+
+#define AON_WRAPPER_MVP_VIDEO_CTL_NOC_LPI_CONTROL (AON_BASE_OFFS + 0x2C)
+#define AON_WRAPPER_MVP_VIDEO_CTL_NOC_LPI_STATUS (AON_BASE_OFFS + 0x30)
+
+#define CPU_NOC_BASE_OFFS 0x000D0000
+#define CPU_NOC_ERRORLOGGER_MAINCTL_LOW (CPU_NOC_BASE_OFFS + 0x08)
+#define CPU_NOC_SBM_FAULTINEN0_LOW (CPU_NOC_BASE_OFFS + 0x240)
+
+#define NOC_BASE_OFFS 0x00010000
+#define NOC_ERL_ERRORLOGGER_MAINCTL_LOW (NOC_BASE_OFFS + 0xA008)
+#define NOC_ERL_ERRORLOGGER_ERRCLR_LOW (NOC_BASE_OFFS + 0xA018)
+#define NOC_SBM_FAULTINEN0_LOW (NOC_BASE_OFFS + 0x7040)
+
+#define NOC5_RESET_VPP0_ONLY_DISABLED 0x36010E
+#define NOC5_RESET_VPP1_DISABLED 0x35000F
+#define NOC5_RESET_ALL_VPP_ENABLED 0x37010F
+
+#define NOC_LPI_PD_QREQ BIT(0)
+#define NOC_SBM_FAULTINEN0_PORT0 BIT(0)
+#define NOC_ERRORLOGGER_MAINCTL_FAULTEN BIT(0)
+#define NOC_ERL_ERRORLOGGER_ERRCLR BIT(0)
+#define AON_MVP_NOC_ARCG_OVERRIDE BIT(0)
+
+#define WRAPPER_INTR_MASK_SS_CPU_NOC BIT(6)
+#define WRAPPER_INTR_MASK_SS_NOC BIT(5)
+
+static bool iris_vpu5x_hw_power_collapsed(struct iris_core *core)
+{
+ u32 value = readl(core->reg_base + WRAPPER_CORE_POWER_STATUS);
+
+ return !(value & CORE_PWR_ON);
+}
+
+static int iris_vpu5x_genpd_set_hwmode(struct iris_core *core, bool hw_mode, u32 efuse_value)
+{
+ int ret;
+
+ ret = iris_genpd_set_hwmode(core->vcodec, hw_mode);
+ if (ret)
+ return ret;
+
+ if (!(efuse_value & DISABLE_VIDEO_VPP0_BIT)) {
+ ret = iris_genpd_set_hwmode(core->vcodec_vpp0, hw_mode);
+ if (ret)
+ goto restore_hw_domain_mode;
+ }
+
+ if (!(efuse_value & DISABLE_VIDEO_VPP1_BIT)) {
+ ret = iris_genpd_set_hwmode(core->vcodec_vpp1, hw_mode);
+ if (ret)
+ goto restore_vpp0_domain_mode;
+ }
+
+ if (!(efuse_value & DISABLE_VIDEO_APV_BIT)) {
+ ret = iris_genpd_set_hwmode(core->apv, hw_mode);
+ if (ret)
+ goto restore_vpp1_domain_mode;
+ }
+
+ ret = iris_genpd_set_hwmode(core->mm_int, hw_mode);
+ if (ret)
+ goto restore_apv_domain_mode;
+
+ ret = iris_genpd_set_hwmode(core->cx_int, hw_mode);
+ if (ret)
+ goto restore_mm_int_domain_mode;
+
+ return 0;
+
+restore_mm_int_domain_mode:
+ iris_genpd_set_hwmode(core->mm_int, !hw_mode);
+restore_apv_domain_mode:
+ if (!(efuse_value & DISABLE_VIDEO_APV_BIT))
+ iris_genpd_set_hwmode(core->apv, !hw_mode);
+restore_vpp1_domain_mode:
+ if (!(efuse_value & DISABLE_VIDEO_VPP1_BIT))
+ iris_genpd_set_hwmode(core->vcodec_vpp1, !hw_mode);
+restore_vpp0_domain_mode:
+ if (!(efuse_value & DISABLE_VIDEO_VPP0_BIT))
+ iris_genpd_set_hwmode(core->vcodec_vpp0, !hw_mode);
+restore_hw_domain_mode:
+ iris_genpd_set_hwmode(core->vcodec, !hw_mode);
+
+ return ret;
+}
+
+static int iris_vpu5x_set_hwmode(struct iris_core *core)
+{
+ u32 efuse_value = readl(core->reg_base + WRAPPER_EFUSE_MONITOR);
+
+ if (!(efuse_value & DISABLE_VIDEO_APV_BIT))
+ iris_vpu_ahb_sync_reset_apv(core);
+
+ iris_vpu_ahb_sync_reset_hardware(core);
+
+ return iris_vpu5x_genpd_set_hwmode(core, true, efuse_value);
+}
+
+/*
+ * Perform an LPI power-down handshake on a single NOC interface.
+ *
+ * Sets QREQ and polls for the status DONE bit. On a busy response the request
+ * is toggled and, when @errclr_offs is non-zero, the NOC error-log clear
+ * register at that offset is written between retries to unblock the fabric.
+ * Pass @errclr_offs = 0 for interfaces that do not require error clearing.
+ */
+static void iris_vpu5x_noc_lpi_handshake(struct iris_core *core,
+ u32 ctrl_offs, u32 status_offs,
+ u32 busy_mask, u32 errclr_offs,
+ const char *name)
+{
+ bool handshake_done, handshake_busy;
+ u32 value, count = 0;
+ int ret;
+
+ do {
+ if (errclr_offs) {
+ value = readl(core->reg_base + errclr_offs);
+ value |= NOC_ERL_ERRORLOGGER_ERRCLR;
+ writel(value, core->reg_base + errclr_offs);
+ }
+
+ value = readl(core->reg_base + ctrl_offs);
+ value |= NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + ctrl_offs);
+ usleep_range(10, 20);
+
+ value = readl(core->reg_base + status_offs);
+ handshake_done = value & NOC_LPI_STATUS_DONE;
+ handshake_busy = value & busy_mask;
+
+ if (handshake_done || !handshake_busy)
+ break;
+
+ value = readl(core->reg_base + ctrl_offs);
+ value &= ~NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + ctrl_offs);
+ usleep_range(10, 20);
+
+ } while (++count < 1000);
+
+ if (!handshake_done && handshake_busy)
+ dev_err(core->dev, "%s NOC LPI handshake timeout\n", name);
+
+ ret = readl_poll_timeout(core->reg_base + status_offs,
+ value, value & NOC_LPI_STATUS_DONE, 200, 2000);
+ if (ret)
+ dev_err(core->dev, "%s NOC LPI status timeout\n", name);
+
+ value = readl(core->reg_base + ctrl_offs);
+ value &= ~NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + ctrl_offs);
+}
+
+static int iris_vpu5x_power_on_cx_int(struct iris_core *core)
+{
+ u32 value;
+ int ret;
+
+ ret = iris_enable_power_domain_and_clocks(core, core->cx_int);
+ if (ret)
+ return ret;
+
+ value = readl(core->reg_base + WRAPPER_MVP_NOC_CX_LPI_CONTROL);
+ value &= ~NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + WRAPPER_MVP_NOC_CX_LPI_CONTROL);
+
+ readl_poll_timeout(core->reg_base + WRAPPER_MVP_NOC_CX_LPI_STATUS,
+ value, !(value & NOC_LPI_STATUS_DONE), 200, 2000);
+
+ return 0;
+}
+
+static void iris_vpu5x_power_off_cx_int(struct iris_core *core)
+{
+ iris_vpu5x_noc_lpi_handshake(core,
+ WRAPPER_MVP_NOC_CX_LPI_CONTROL,
+ WRAPPER_MVP_NOC_CX_LPI_STATUS,
+ NOC_LPI_STATUS_DENY | NOC_LPI_STATUS_ACTIVE,
+ NOC_ERL_ERRORLOGGER_ERRCLR_LOW, "CX");
+
+ iris_disable_power_domain_and_clocks(core, core->cx_int);
+}
+
+static int iris_vpu5x_power_on_mm_int(struct iris_core *core)
+{
+ u32 value;
+ int ret;
+
+ ret = iris_enable_power_domain_and_clocks(core, core->mm_int);
+ if (ret)
+ return ret;
+
+ value = readl(core->reg_base + WRAPPER_MVP_NOC_LPI_CONTROL);
+ value &= ~NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + WRAPPER_MVP_NOC_LPI_CONTROL);
+
+ readl_poll_timeout(core->reg_base + WRAPPER_MVP_NOC_LPI_STATUS,
+ value, !(value & NOC_LPI_STATUS_DONE), 200, 2000);
+
+ return 0;
+}
+
+static void iris_vpu5x_power_off_mm_int(struct iris_core *core)
+{
+ u32 value;
+
+ value = readl(core->reg_base + WRAPPER_MVP_NOC_LPI_CONTROL);
+ value &= ~NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + WRAPPER_MVP_NOC_LPI_CONTROL);
+
+ value = readl(core->reg_base + WRAPPER_MVP_NOC_CX_LPI_CONTROL);
+ value &= ~NOC_LPI_PD_QREQ;
+ writel(value, core->reg_base + WRAPPER_MVP_NOC_CX_LPI_CONTROL);
+
+ iris_vpu5x_noc_lpi_handshake(core,
+ WRAPPER_MVP_NOC_LPI_CONTROL,
+ WRAPPER_MVP_NOC_LPI_STATUS,
+ NOC_LPI_STATUS_DENY | NOC_LPI_STATUS_ACTIVE,
+ NOC_ERL_ERRORLOGGER_ERRCLR_LOW, "MM");
+
+ iris_disable_power_domain_and_clocks(core, core->mm_int);
+}
+
+static int iris_vpu5x_power_on_hardware(struct iris_core *core)
+{
+ u32 efuse_value = readl(core->reg_base + WRAPPER_EFUSE_MONITOR);
+ int ret;
+
+ ret = iris_vpu5x_power_on_cx_int(core);
+ if (ret)
+ return ret;
+
+ ret = iris_vpu5x_power_on_mm_int(core);
+ if (ret)
+ goto err_disable_cx_int;
+
+ ret = iris_enable_power_domain_and_clocks(core, core->vcodec);
+ if (ret)
+ goto err_disable_mm_int;
+
+ if (!(efuse_value & DISABLE_VIDEO_VPP0_BIT)) {
+ ret = iris_enable_power_domain_and_clocks(core, core->vcodec_vpp0);
+ if (ret)
+ goto err_disable_hw_power;
+ }
+
+ if (!(efuse_value & DISABLE_VIDEO_VPP1_BIT)) {
+ ret = iris_enable_power_domain_and_clocks(core, core->vcodec_vpp1);
+ if (ret)
+ goto err_disable_vpp0_power;
+ }
+
+ if (!(efuse_value & DISABLE_VIDEO_APV_BIT)) {
+ ret = iris_vpu_power_on_apv(core);
+ if (ret)
+ goto err_disable_vpp1_power;
+ }
+
+ return 0;
+
+err_disable_vpp1_power:
+ if (!(efuse_value & DISABLE_VIDEO_VPP1_BIT))
+ iris_disable_power_domain_and_clocks(core, core->vcodec_vpp1);
+err_disable_vpp0_power:
+ if (!(efuse_value & DISABLE_VIDEO_VPP0_BIT))
+ iris_disable_power_domain_and_clocks(core, core->vcodec_vpp0);
+err_disable_hw_power:
+ iris_disable_power_domain_and_clocks(core, core->vcodec);
+err_disable_mm_int:
+ iris_vpu5x_power_off_mm_int(core);
+err_disable_cx_int:
+ iris_vpu5x_power_off_cx_int(core);
+
+ return ret;
+}
+
+static void iris_vpu5x_power_off_hardware(struct iris_core *core)
+{
+ u32 efuse_value = readl(core->reg_base + WRAPPER_EFUSE_MONITOR);
+ u32 noc_reset_mask;
+ u32 value;
+ int ret;
+
+ iris_vpu5x_genpd_set_hwmode(core, false, efuse_value);
+
+ if (!(efuse_value & DISABLE_VIDEO_APV_BIT))
+ iris_vpu_power_off_apv(core);
+
+ if (iris_vpu5x_hw_power_collapsed(core))
+ goto disable_clocks_and_power;
+
+ value = readl(core->reg_base + WRAPPER_CORE_CLOCK_CONFIG);
+ if (value & CORE_CLK_HALT)
+ writel(CORE_CLK_RUN, core->reg_base + WRAPPER_CORE_CLOCK_CONFIG);
+
+ readl_poll_timeout(core->reg_base + VCODEC_SS_IDLE_STATUSN,
+ value, (value & VPU_IDLE_BITS) == VPU_IDLE_BITS, 2000, 20000);
+
+ if (efuse_value & DISABLE_VIDEO_VPP0_BIT)
+ noc_reset_mask = NOC5_RESET_VPP0_ONLY_DISABLED;
+ else if (efuse_value & DISABLE_VIDEO_VPP1_BIT)
+ noc_reset_mask = NOC5_RESET_VPP1_DISABLED;
+ else
+ noc_reset_mask = NOC5_RESET_ALL_VPP_ENABLED;
+
+ writel(noc_reset_mask, core->reg_base + AON_WRAPPER_MVP_NOC_RESET_REQ);
+ ret = readl_poll_timeout(core->reg_base + AON_WRAPPER_MVP_NOC_RESET_ACK,
+ value, (value & noc_reset_mask) == noc_reset_mask, 200, 2000);
+ if (ret)
+ dev_err(core->dev, "MVP NOC reset ack timeout\n");
+
+ writel(noc_reset_mask, core->reg_base + AON_WRAPPER_MVP_NOC_RESET_SYNCRST);
+ writel(0x0, core->reg_base + AON_WRAPPER_MVP_NOC_RESET_SYNCRST);
+ writel(0x0, core->reg_base + AON_WRAPPER_MVP_NOC_RESET_REQ);
+
+ ret = readl_poll_timeout(core->reg_base + AON_WRAPPER_MVP_NOC_RESET_ACK,
+ value, value == 0x0, 200, 2000);
+ if (ret)
+ dev_err(core->dev, "MVP NOC reset deassert timeout\n");
+
+ writel(CORE_BRIDGE_SW_RESET | CORE_BRIDGE_HW_RESET_DISABLE,
+ core->reg_base + CPU_CS_AHB_BRIDGE_SYNC_RESET);
+ writel(CORE_BRIDGE_HW_RESET_DISABLE, core->reg_base + CPU_CS_AHB_BRIDGE_SYNC_RESET);
+ writel(0x0, core->reg_base + CPU_CS_AHB_BRIDGE_SYNC_RESET);
+
+disable_clocks_and_power:
+ if (!(efuse_value & DISABLE_VIDEO_VPP1_BIT))
+ iris_disable_power_domain_and_clocks(core, core->vcodec_vpp1);
+
+ if (!(efuse_value & DISABLE_VIDEO_VPP0_BIT))
+ iris_disable_power_domain_and_clocks(core, core->vcodec_vpp0);
+
+ iris_disable_power_domain_and_clocks(core, core->vcodec);
+ iris_vpu5x_power_off_mm_int(core);
+ iris_vpu5x_power_off_cx_int(core);
+}
+
+static int iris_vpu5x_power_on_controller(struct iris_core *core)
+{
+ u32 mask_val;
+ int ret;
+
+ ret = iris_enable_power_domain_and_clocks(core, core->ctrl);
+ if (ret)
+ return ret;
+
+ mask_val = readl(core->reg_base + CPU_NOC_SBM_FAULTINEN0_LOW);
+ mask_val |= NOC_SBM_FAULTINEN0_PORT0;
+ writel(mask_val, core->reg_base + CPU_NOC_SBM_FAULTINEN0_LOW);
+
+ mask_val = readl(core->reg_base + CPU_NOC_ERRORLOGGER_MAINCTL_LOW);
+ mask_val |= NOC_ERRORLOGGER_MAINCTL_FAULTEN;
+ writel(mask_val, core->reg_base + CPU_NOC_ERRORLOGGER_MAINCTL_LOW);
+
+ mask_val = readl(core->reg_base + WRAPPER_INTR_MASK);
+ mask_val &= ~WRAPPER_INTR_MASK_SS_CPU_NOC;
+ writel(mask_val, core->reg_base + WRAPPER_INTR_MASK);
+
+ mask_val = readl(core->reg_base + NOC_SBM_FAULTINEN0_LOW);
+ mask_val |= NOC_SBM_FAULTINEN0_PORT0;
+ writel(mask_val, core->reg_base + NOC_SBM_FAULTINEN0_LOW);
+
+ mask_val = readl(core->reg_base + NOC_ERL_ERRORLOGGER_MAINCTL_LOW);
+ mask_val |= NOC_ERRORLOGGER_MAINCTL_FAULTEN;
+ writel(mask_val, core->reg_base + NOC_ERL_ERRORLOGGER_MAINCTL_LOW);
+
+ mask_val = readl(core->reg_base + WRAPPER_INTR_MASK);
+ mask_val &= ~WRAPPER_INTR_MASK_SS_NOC;
+ writel(mask_val, core->reg_base + WRAPPER_INTR_MASK);
+
+ return 0;
+}
+
+static int iris_vpu5x_power_off_controller(struct iris_core *core)
+{
+ u32 ctrl_rst_tbl_size = core->iris_platform_data->controller_rst_tbl_size;
+ u32 value;
+
+ writel(MSK_SIGNAL_FROM_TENSILICA | MSK_CORE_POWER_ON,
+ core->reg_base + CPU_CS_X2RPMH);
+
+ iris_vpu5x_noc_lpi_handshake(core,
+ WRAPPER_IRIS_CPU_NOC_LPI_CONTROL,
+ WRAPPER_IRIS_CPU_NOC_LPI_STATUS,
+ NOC_LPI_STATUS_DENY, 0, "CPU");
+
+ iris_vpu5x_noc_lpi_handshake(core,
+ AON_WRAPPER_MVP_VIDEO_CTL_NOC_LPI_CONTROL,
+ AON_WRAPPER_MVP_VIDEO_CTL_NOC_LPI_STATUS,
+ NOC_LPI_STATUS_DENY | NOC_LPI_STATUS_ACTIVE, 0, "Video CTL");
+
+ writel(0x0, core->reg_base + WRAPPER_DEBUG_BRIDGE_LPI_CONTROL);
+ readl_poll_timeout(core->reg_base + WRAPPER_DEBUG_BRIDGE_LPI_STATUS,
+ value, value == 0x0, 200, 2000);
+
+ value = readl(core->reg_base + AON_WRAPPER_MVP_NOC_ARCG_CONTROL);
+ value |= AON_MVP_NOC_ARCG_OVERRIDE;
+ writel(value, core->reg_base + AON_WRAPPER_MVP_NOC_ARCG_CONTROL);
+
+ iris_disable_power_domain_and_clocks(core, core->ctrl);
+
+ reset_control_bulk_assert(ctrl_rst_tbl_size, core->controller_resets);
+ usleep_range(400, 500);
+ reset_control_bulk_deassert(ctrl_rst_tbl_size, core->controller_resets);
+
+ return 0;
+}
+
+const struct vpu_ops iris_vpu5x_ops = {
+ .power_off_hw = iris_vpu5x_power_off_hardware,
+ .power_on_hw = iris_vpu5x_power_on_hardware,
+ .power_off_controller = iris_vpu5x_power_off_controller,
+ .power_on_controller = iris_vpu5x_power_on_controller,
+ .program_bootup_registers = iris_vpu35_vpu4x_program_bootup_registers,
+ .calc_freq = iris_vpu3x_vpu4x_calculate_frequency,
+ .set_hwmode = iris_vpu5x_set_hwmode,
+ .interrupt_init = iris_vpu_interrupt_init,
+ .set_preset_registers = iris_vpu_set_preset_registers,
+};
diff --git a/drivers/media/platform/qcom/iris/iris_vpu_common.h b/drivers/media/platform/qcom/iris/iris_vpu_common.h
index 126555877561e3a9bbaef7fa4da329bbe6645d46..783e2429be28dffe829b0adba998a9a02a7b883b 100644
--- a/drivers/media/platform/qcom/iris/iris_vpu_common.h
+++ b/drivers/media/platform/qcom/iris/iris_vpu_common.h
@@ -13,6 +13,7 @@ extern const struct vpu_ops iris_vpu3_ops;
extern const struct vpu_ops iris_vpu33_ops;
extern const struct vpu_ops iris_vpu35_ops;
extern const struct vpu_ops iris_vpu4x_ops;
+extern const struct vpu_ops iris_vpu5x_ops;
extern const struct vpu_ops iris_vpu_ar50lt_ops;

struct vpu_ops {

--
2.43.0