Quelle  pvr_rogue_fwif.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only OR MIT */
/* Copyright (c) 2023 Imagination Technologies Ltd. */

#ifndef PVR_ROGUE_FWIF_H
#define PVR_ROGUE_FWIF_H

#include <linux/bits.h>
#include <linux/build_bug.h>
#include <linux/compiler.h>
#include <linux/kernel.h>
#include <linux/types.h>

#include "pvr_rogue_defs.h"
#include "pvr_rogue_fwif_common.h"
#include "pvr_rogue_fwif_shared.h"

/*
 ****************************************************************************
 * Logging type
 ****************************************************************************
 */
#define ROGUE_FWIF_LOG_TYPE_NONE 0x00000000U
#define ROGUE_FWIF_LOG_TYPE_TRACE 0x00000001U
#define ROGUE_FWIF_LOG_TYPE_GROUP_MAIN 0x00000002U
#define ROGUE_FWIF_LOG_TYPE_GROUP_MTS 0x00000004U
#define ROGUE_FWIF_LOG_TYPE_GROUP_CLEANUP 0x00000008U
#define ROGUE_FWIF_LOG_TYPE_GROUP_CSW 0x00000010U
#define ROGUE_FWIF_LOG_TYPE_GROUP_BIF 0x00000020U
#define ROGUE_FWIF_LOG_TYPE_GROUP_PM 0x00000040U
#define ROGUE_FWIF_LOG_TYPE_GROUP_RTD 0x00000080U
#define ROGUE_FWIF_LOG_TYPE_GROUP_SPM 0x00000100U
#define ROGUE_FWIF_LOG_TYPE_GROUP_POW 0x00000200U
#define ROGUE_FWIF_LOG_TYPE_GROUP_HWR 0x00000400U
#define ROGUE_FWIF_LOG_TYPE_GROUP_HWP 0x00000800U
#define ROGUE_FWIF_LOG_TYPE_GROUP_RPM 0x00001000U
#define ROGUE_FWIF_LOG_TYPE_GROUP_DMA 0x00002000U
#define ROGUE_FWIF_LOG_TYPE_GROUP_MISC 0x00004000U
#define ROGUE_FWIF_LOG_TYPE_GROUP_DEBUG 0x80000000U
#define ROGUE_FWIF_LOG_TYPE_GROUP_MASK 0x80007FFEU
#define ROGUE_FWIF_LOG_TYPE_MASK 0x80007FFFU

/* String used in pvrdebug -h output */
#define ROGUE_FWIF_LOG_GROUPS_STRING_LIST \
 "main,mts,cleanup,csw,bif,pm,rtd,spm,pow,hwr,hwp,rpm,dma,misc,debug"

/* Table entry to map log group strings to log type value */
struct rogue_fwif_log_group_map_entry {
 const char *log_group_name;
 u32 log_group_type;
};

/*
 ****************************************************************************
 * ROGUE FW signature checks
 ****************************************************************************
 */
#define ROGUE_FW_SIG_BUFFER_SIZE_MIN (8192)

#define ROGUE_FWIF_TIMEDIFF_ID ((0x1UL << 28) | ROGUE_CR_TIMER)

/*
 ****************************************************************************
 * Trace Buffer
 ****************************************************************************
 */

/* Default size of ROGUE_FWIF_TRACEBUF_SPACE in DWords */
#define ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS 12000U
#define ROGUE_FW_TRACE_BUFFER_ASSERT_SIZE 200U
#define ROGUE_FW_THREAD_NUM 1U
#define ROGUE_FW_THREAD_MAX 2U

#define ROGUE_FW_POLL_TYPE_SET 0x80000000U

struct rogue_fwif_file_info_buf {
 char path[ROGUE_FW_TRACE_BUFFER_ASSERT_SIZE];
 char info[ROGUE_FW_TRACE_BUFFER_ASSERT_SIZE];
 u32 line_num;
 u32 padding;
} __aligned(8);

struct rogue_fwif_tracebuf_space {
 u32 trace_pointer;

 u32 trace_buffer_fw_addr;

 /* To be used by host when reading from trace buffer */
 u32 *trace_buffer;

 struct rogue_fwif_file_info_buf assert_buf;
} __aligned(8);

/* Total number of FW fault logs stored */
#define ROGUE_FWIF_FWFAULTINFO_MAX (8U)

struct rogue_fw_fault_info {
 aligned_u64 cr_timer;
 aligned_u64 os_timer;

 u32 data __aligned(8);
 u32 reserved;
 struct rogue_fwif_file_info_buf fault_buf;
} __aligned(8);

enum rogue_fwif_pow_state {
 ROGUE_FWIF_POW_OFF, /* idle and ready to full power down */
 ROGUE_FWIF_POW_ON, /* running HW commands */
 ROGUE_FWIF_POW_FORCED_IDLE, /* forced idle */
 ROGUE_FWIF_POW_IDLE, /* idle waiting for host handshake */
};

/* Firmware HWR states */
/* The HW state is ok or locked up */
#define ROGUE_FWIF_HWR_HARDWARE_OK BIT(0)
/* Tells if a HWR reset is in progress */
#define ROGUE_FWIF_HWR_RESET_IN_PROGRESS BIT(1)
/* A DM unrelated lockup has been detected */
#define ROGUE_FWIF_HWR_GENERAL_LOCKUP BIT(3)
/* At least one DM is running without being close to a lockup */
#define ROGUE_FWIF_HWR_DM_RUNNING_OK BIT(4)
/* At least one DM is close to lockup */
#define ROGUE_FWIF_HWR_DM_STALLING BIT(5)
/* The FW has faulted and needs to restart */
#define ROGUE_FWIF_HWR_FW_FAULT BIT(6)
/* The FW has requested the host to restart it */
#define ROGUE_FWIF_HWR_RESTART_REQUESTED BIT(7)

#define ROGUE_FWIF_PHR_STATE_SHIFT (8U)
/* The FW has requested the host to restart it, per PHR configuration */
#define ROGUE_FWIF_PHR_RESTART_REQUESTED ((1) << ROGUE_FWIF_PHR_STATE_SHIFT)
/* A PHR triggered GPU reset has just finished */
#define ROGUE_FWIF_PHR_RESTART_FINISHED ((2) << ROGUE_FWIF_PHR_STATE_SHIFT)
#define ROGUE_FWIF_PHR_RESTART_MASK \
 (ROGUE_FWIF_PHR_RESTART_REQUESTED | ROGUE_FWIF_PHR_RESTART_FINISHED)

#define ROGUE_FWIF_PHR_MODE_OFF (0UL)
#define ROGUE_FWIF_PHR_MODE_RD_RESET (1UL)
#define ROGUE_FWIF_PHR_MODE_FULL_RESET (2UL)

/* Firmware per-DM HWR states */
/* DM is working if all flags are cleared */
#define ROGUE_FWIF_DM_STATE_WORKING (0)
/* DM is idle and ready for HWR */
#define ROGUE_FWIF_DM_STATE_READY_FOR_HWR BIT(0)
/* DM need to skip to next cmd before resuming processing */
#define ROGUE_FWIF_DM_STATE_NEEDS_SKIP BIT(2)
/* DM need partial render cleanup before resuming processing */
#define ROGUE_FWIF_DM_STATE_NEEDS_PR_CLEANUP BIT(3)
/* DM need to increment Recovery Count once fully recovered */
#define ROGUE_FWIF_DM_STATE_NEEDS_TRACE_CLEAR BIT(4)
/* DM was identified as locking up and causing HWR */
#define ROGUE_FWIF_DM_STATE_GUILTY_LOCKUP BIT(5)
/* DM was innocently affected by another lockup which caused HWR */
#define ROGUE_FWIF_DM_STATE_INNOCENT_LOCKUP BIT(6)
/* DM was identified as over-running and causing HWR */
#define ROGUE_FWIF_DM_STATE_GUILTY_OVERRUNING BIT(7)
/* DM was innocently affected by another DM over-running which caused HWR */
#define ROGUE_FWIF_DM_STATE_INNOCENT_OVERRUNING BIT(8)
/* DM was forced into HWR as it delayed more important workloads */
#define ROGUE_FWIF_DM_STATE_HARD_CONTEXT_SWITCH BIT(9)
/* DM was forced into HWR due to an uncorrected GPU ECC error */
#define ROGUE_FWIF_DM_STATE_GPU_ECC_HWR BIT(10)

/* Firmware's connection state */
enum rogue_fwif_connection_fw_state {
 /* Firmware is offline */
 ROGUE_FW_CONNECTION_FW_OFFLINE = 0,
 /* Firmware is initialised */
 ROGUE_FW_CONNECTION_FW_READY,
 /* Firmware connection is fully established */
 ROGUE_FW_CONNECTION_FW_ACTIVE,
 /* Firmware is clearing up connection data*/
 ROGUE_FW_CONNECTION_FW_OFFLOADING,
 ROGUE_FW_CONNECTION_FW_STATE_COUNT
};

/* OS' connection state */
enum rogue_fwif_connection_os_state {
 /* OS is offline */
 ROGUE_FW_CONNECTION_OS_OFFLINE = 0,
 /* OS's KM driver is setup and waiting */
 ROGUE_FW_CONNECTION_OS_READY,
 /* OS connection is fully established */
 ROGUE_FW_CONNECTION_OS_ACTIVE,
 ROGUE_FW_CONNECTION_OS_STATE_COUNT
};

struct rogue_fwif_os_runtime_flags {
 unsigned int os_state : 3;
 unsigned int fl_ok : 1;
 unsigned int fl_grow_pending : 1;
 unsigned int isolated_os : 1;
 unsigned int reserved : 26;
};

#define PVR_SLR_LOG_ENTRIES 10
/* MAX_CLIENT_CCB_NAME not visible to this header */
#define PVR_SLR_LOG_STRLEN 30

struct rogue_fwif_slr_entry {
 aligned_u64 timestamp;
 u32 fw_ctx_addr;
 u32 num_ufos;
 char ccb_name[PVR_SLR_LOG_STRLEN];
 char padding[2];
} __aligned(8);

#define MAX_THREAD_NUM 2

/* firmware trace control data */
struct rogue_fwif_tracebuf {
 u32 log_type;
 struct rogue_fwif_tracebuf_space tracebuf[MAX_THREAD_NUM];
 /*
 * Member initialised only when sTraceBuf is actually allocated (in
 * ROGUETraceBufferInitOnDemandResources)
 */
 u32 tracebuf_size_in_dwords;
 /* Compatibility and other flags */
 u32 tracebuf_flags;
} __aligned(8);

/* firmware system data shared with the Host driver */
struct rogue_fwif_sysdata {
 /* Configuration flags from host */
 u32 config_flags;
 /* Extended configuration flags from host */
 u32 config_flags_ext;
 enum rogue_fwif_pow_state pow_state;
 u32 hw_perf_ridx;
 u32 hw_perf_widx;
 u32 hw_perf_wrap_count;
 /* Constant after setup, needed in FW */
 u32 hw_perf_size;
 /* The number of times the FW drops a packet due to buffer full */
 u32 hw_perf_drop_count;

 /*
 * ui32HWPerfUt, ui32FirstDropOrdinal, ui32LastDropOrdinal only valid
 * when FW is built with ROGUE_HWPERF_UTILIZATION &
 * ROGUE_HWPERF_DROP_TRACKING defined in rogue_fw_hwperf.c
 */
 /* Buffer utilisation, high watermark of bytes in use */
 u32 hw_perf_ut;
 /* The ordinal of the first packet the FW dropped */
 u32 first_drop_ordinal;
 /* The ordinal of the last packet the FW dropped */
 u32 last_drop_ordinal;
 /* State flags for each Operating System mirrored from Fw coremem */
 struct rogue_fwif_os_runtime_flags
  os_runtime_flags_mirror[ROGUE_FW_MAX_NUM_OS];

 struct rogue_fw_fault_info fault_info[ROGUE_FWIF_FWFAULTINFO_MAX];
 u32 fw_faults;
 u32 cr_poll_addr[MAX_THREAD_NUM];
 u32 cr_poll_mask[MAX_THREAD_NUM];
 u32 cr_poll_count[MAX_THREAD_NUM];
 aligned_u64 start_idle_time;

#if defined(SUPPORT_ROGUE_FW_STATS_FRAMEWORK)
# define ROGUE_FWIF_STATS_FRAMEWORK_LINESIZE (8)
# define ROGUE_FWIF_STATS_FRAMEWORK_MAX \
  (2048 * ROGUE_FWIF_STATS_FRAMEWORK_LINESIZE)
 u32 fw_stats_buf[ROGUE_FWIF_STATS_FRAMEWORK_MAX] __aligned(8);
#endif
 u32 hwr_state_flags;
 u32 hwr_recovery_flags[PVR_FWIF_DM_MAX];
 /* Compatibility and other flags */
 u32 fw_sys_data_flags;
 /* Identify whether MC config is P-P or P-S */
 u32 mc_config;
} __aligned(8);

/* per-os firmware shared data */
struct rogue_fwif_osdata {
 /* Configuration flags from an OS */
 u32 fw_os_config_flags;
 /* Markers to signal that the host should perform a full sync check */
 u32 fw_sync_check_mark;
 u32 host_sync_check_mark;

 u32 forced_updates_requested;
 u8 slr_log_wp;
 struct rogue_fwif_slr_entry slr_log_first;
 struct rogue_fwif_slr_entry slr_log[PVR_SLR_LOG_ENTRIES];
 aligned_u64 last_forced_update_time;

 /* Interrupt count from Threads > */
 u32 interrupt_count[MAX_THREAD_NUM];
 u32 kccb_cmds_executed;
 u32 power_sync_fw_addr;
 /* Compatibility and other flags */
 u32 fw_os_data_flags;
 u32 padding;
} __aligned(8);

/* Firmware trace time-stamp field breakup */

/* ROGUE_CR_TIMER register read (48 bits) value*/
#define ROGUE_FWT_TIMESTAMP_TIME_SHIFT (0U)
#define ROGUE_FWT_TIMESTAMP_TIME_CLRMSK (0xFFFF000000000000ull)

/* Extra debug-info (16 bits) */
#define ROGUE_FWT_TIMESTAMP_DEBUG_INFO_SHIFT (48U)
#define ROGUE_FWT_TIMESTAMP_DEBUG_INFO_CLRMSK ~ROGUE_FWT_TIMESTAMP_TIME_CLRMSK

/* Debug-info sub-fields */
/*
 * Bit 0: ROGUE_CR_EVENT_STATUS_MMU_PAGE_FAULT bit from ROGUE_CR_EVENT_STATUS
 * register
 */
#define ROGUE_FWT_DEBUG_INFO_MMU_PAGE_FAULT_SHIFT (0U)
#define ROGUE_FWT_DEBUG_INFO_MMU_PAGE_FAULT_SET \
 BIT(ROGUE_FWT_DEBUG_INFO_MMU_PAGE_FAULT_SHIFT)

/* Bit 1: ROGUE_CR_BIF_MMU_ENTRY_PENDING bit from ROGUE_CR_BIF_MMU_ENTRY register */
#define ROGUE_FWT_DEBUG_INFO_MMU_ENTRY_PENDING_SHIFT (1U)
#define ROGUE_FWT_DEBUG_INFO_MMU_ENTRY_PENDING_SET \
 BIT(ROGUE_FWT_DEBUG_INFO_MMU_ENTRY_PENDING_SHIFT)

/* Bit 2: ROGUE_CR_SLAVE_EVENT register is non-zero */
#define ROGUE_FWT_DEBUG_INFO_SLAVE_EVENTS_SHIFT (2U)
#define ROGUE_FWT_DEBUG_INFO_SLAVE_EVENTS_SET \
 BIT(ROGUE_FWT_DEBUG_INFO_SLAVE_EVENTS_SHIFT)

/* Bit 3-15: Unused bits */

#define ROGUE_FWT_DEBUG_INFO_STR_MAXLEN 64
#define ROGUE_FWT_DEBUG_INFO_STR_PREPEND " (debug info: "
#define ROGUE_FWT_DEBUG_INFO_STR_APPEND ")"

/*
 ******************************************************************************
 * HWR Data
 ******************************************************************************
 */
enum rogue_hwrtype {
 ROGUE_HWRTYPE_UNKNOWNFAILURE = 0,
 ROGUE_HWRTYPE_OVERRUN = 1,
 ROGUE_HWRTYPE_POLLFAILURE = 2,
 ROGUE_HWRTYPE_BIF0FAULT = 3,
 ROGUE_HWRTYPE_BIF1FAULT = 4,
 ROGUE_HWRTYPE_TEXASBIF0FAULT = 5,
 ROGUE_HWRTYPE_MMUFAULT = 6,
 ROGUE_HWRTYPE_MMUMETAFAULT = 7,
 ROGUE_HWRTYPE_MIPSTLBFAULT = 8,
 ROGUE_HWRTYPE_ECCFAULT = 9,
 ROGUE_HWRTYPE_MMURISCVFAULT = 10,
};

#define ROGUE_FWIF_HWRTYPE_BIF_BANK_GET(hwr_type) \
 (((hwr_type) == ROGUE_HWRTYPE_BIF0FAULT) ? 0 : 1)

#define ROGUE_FWIF_HWRTYPE_PAGE_FAULT_GET(hwr_type)       \
 ((((hwr_type) == ROGUE_HWRTYPE_BIF0FAULT) ||      \
   ((hwr_type) == ROGUE_HWRTYPE_BIF1FAULT) ||      \
   ((hwr_type) == ROGUE_HWRTYPE_TEXASBIF0FAULT) || \
   ((hwr_type) == ROGUE_HWRTYPE_MMUFAULT) ||       \
   ((hwr_type) == ROGUE_HWRTYPE_MMUMETAFAULT) ||   \
   ((hwr_type) == ROGUE_HWRTYPE_MIPSTLBFAULT) ||   \
   ((hwr_type) == ROGUE_HWRTYPE_MMURISCVFAULT))    \
   ? true                                   \
   : false)

struct rogue_bifinfo {
 aligned_u64 bif_req_status;
 aligned_u64 bif_mmu_status;
 aligned_u64 pc_address; /* phys address of the page catalogue */
 aligned_u64 reserved;
};

struct rogue_eccinfo {
 u32 fault_gpu;
};

struct rogue_mmuinfo {
 aligned_u64 mmu_status[2];
 aligned_u64 pc_address; /* phys address of the page catalogue */
 aligned_u64 reserved;
};

struct rogue_pollinfo {
 u32 thread_num;
 u32 cr_poll_addr;
 u32 cr_poll_mask;
 u32 cr_poll_last_value;
 aligned_u64 reserved;
} __aligned(8);

struct rogue_tlbinfo {
 u32 bad_addr;
 u32 entry_lo;
};

struct rogue_hwrinfo {
 union {
  struct rogue_bifinfo bif_info;
  struct rogue_mmuinfo mmu_info;
  struct rogue_pollinfo poll_info;
  struct rogue_tlbinfo tlb_info;
  struct rogue_eccinfo ecc_info;
 } hwr_data;

 aligned_u64 cr_timer;
 aligned_u64 os_timer;
 u32 frame_num;
 u32 pid;
 u32 active_hwrt_data;
 u32 hwr_number;
 u32 event_status;
 u32 hwr_recovery_flags;
 enum rogue_hwrtype hwr_type;
 u32 dm;
 u32 core_id;
 aligned_u64 cr_time_of_kick;
 aligned_u64 cr_time_hw_reset_start;
 aligned_u64 cr_time_hw_reset_finish;
 aligned_u64 cr_time_freelist_ready;
 aligned_u64 reserved[2];
} __aligned(8);

/* Number of first HWR logs recorded (never overwritten by newer logs) */
#define ROGUE_FWIF_HWINFO_MAX_FIRST 8U
/* Number of latest HWR logs (older logs are overwritten by newer logs) */
#define ROGUE_FWIF_HWINFO_MAX_LAST 8U
/* Total number of HWR logs stored in a buffer */
#define ROGUE_FWIF_HWINFO_MAX \
 (ROGUE_FWIF_HWINFO_MAX_FIRST + ROGUE_FWIF_HWINFO_MAX_LAST)
/* Index of the last log in the HWR log buffer */
#define ROGUE_FWIF_HWINFO_LAST_INDEX (ROGUE_FWIF_HWINFO_MAX - 1U)

struct rogue_fwif_hwrinfobuf {
 struct rogue_hwrinfo hwr_info[ROGUE_FWIF_HWINFO_MAX];
 u32 hwr_counter;
 u32 write_index;
 u32 dd_req_count;
 u32 hwr_info_buf_flags; /* Compatibility and other flags */
 u32 hwr_dm_locked_up_count[PVR_FWIF_DM_MAX];
 u32 hwr_dm_overran_count[PVR_FWIF_DM_MAX];
 u32 hwr_dm_recovered_count[PVR_FWIF_DM_MAX];
 u32 hwr_dm_false_detect_count[PVR_FWIF_DM_MAX];
} __aligned(8);

#define ROGUE_FWIF_CTXSWITCH_PROFILE_FAST_EN (1)
#define ROGUE_FWIF_CTXSWITCH_PROFILE_MEDIUM_EN (2)
#define ROGUE_FWIF_CTXSWITCH_PROFILE_SLOW_EN (3)
#define ROGUE_FWIF_CTXSWITCH_PROFILE_NODELAY_EN (4)

#define ROGUE_FWIF_CDM_ARBITRATION_TASK_DEMAND_EN (1)
#define ROGUE_FWIF_CDM_ARBITRATION_ROUND_ROBIN_EN (2)

#define ROGUE_FWIF_ISP_SCHEDMODE_VER1_IPP (1)
#define ROGUE_FWIF_ISP_SCHEDMODE_VER2_ISP (2)
/*
 ******************************************************************************
 * ROGUE firmware Init Config Data
 ******************************************************************************
 */

/* Flag definitions affecting the firmware globally */
#define ROGUE_FWIF_INICFG_CTXSWITCH_MODE_RAND BIT(0)
#define ROGUE_FWIF_INICFG_CTXSWITCH_SRESET_EN BIT(1)
#define ROGUE_FWIF_INICFG_HWPERF_EN BIT(2)
#define ROGUE_FWIF_INICFG_DM_KILL_MODE_RAND_EN BIT(3)
#define ROGUE_FWIF_INICFG_POW_RASCALDUST BIT(4)
/* Bit 5 is reserved. */
#define ROGUE_FWIF_INICFG_FBCDC_V3_1_EN BIT(6)
#define ROGUE_FWIF_INICFG_CHECK_MLIST_EN BIT(7)
#define ROGUE_FWIF_INICFG_DISABLE_CLKGATING_EN BIT(8)
/* Bit 9 is reserved. */
/* Bit 10 is reserved. */
/* Bit 11 is reserved. */
#define ROGUE_FWIF_INICFG_REGCONFIG_EN BIT(12)
#define ROGUE_FWIF_INICFG_ASSERT_ON_OUTOFMEMORY BIT(13)
#define ROGUE_FWIF_INICFG_HWP_DISABLE_FILTER BIT(14)
/* Bit 15 is reserved. */
#define ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SHIFT (16)
#define ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_FAST \
 (ROGUE_FWIF_CTXSWITCH_PROFILE_FAST_EN    \
  << ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SHIFT)
#define ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_MEDIUM \
 (ROGUE_FWIF_CTXSWITCH_PROFILE_MEDIUM_EN    \
  << ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SHIFT)
#define ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SLOW \
 (ROGUE_FWIF_CTXSWITCH_PROFILE_SLOW_EN    \
  << ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SHIFT)
#define ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_NODELAY \
 (ROGUE_FWIF_CTXSWITCH_PROFILE_NODELAY_EN    \
  << ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SHIFT)
#define ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_MASK \
 (7 << ROGUE_FWIF_INICFG_CTXSWITCH_PROFILE_SHIFT)
#define ROGUE_FWIF_INICFG_DISABLE_DM_OVERLAP BIT(19)
#define ROGUE_FWIF_INICFG_ASSERT_ON_HWR_TRIGGER BIT(20)
#define ROGUE_FWIF_INICFG_FABRIC_COHERENCY_ENABLED BIT(21)
#define ROGUE_FWIF_INICFG_VALIDATE_IRQ BIT(22)
#define ROGUE_FWIF_INICFG_DISABLE_PDP_EN BIT(23)
#define ROGUE_FWIF_INICFG_SPU_POWER_STATE_MASK_CHANGE_EN BIT(24)
#define ROGUE_FWIF_INICFG_WORKEST BIT(25)
#define ROGUE_FWIF_INICFG_PDVFS BIT(26)
#define ROGUE_FWIF_INICFG_CDM_ARBITRATION_SHIFT (27)
#define ROGUE_FWIF_INICFG_CDM_ARBITRATION_TASK_DEMAND \
 (ROGUE_FWIF_CDM_ARBITRATION_TASK_DEMAND_EN    \
  << ROGUE_FWIF_INICFG_CDM_ARBITRATION_SHIFT)
#define ROGUE_FWIF_INICFG_CDM_ARBITRATION_ROUND_ROBIN \
 (ROGUE_FWIF_CDM_ARBITRATION_ROUND_ROBIN_EN    \
  << ROGUE_FWIF_INICFG_CDM_ARBITRATION_SHIFT)
#define ROGUE_FWIF_INICFG_CDM_ARBITRATION_MASK \
 (3 << ROGUE_FWIF_INICFG_CDM_ARBITRATION_SHIFT)
#define ROGUE_FWIF_INICFG_ISPSCHEDMODE_SHIFT (29)
#define ROGUE_FWIF_INICFG_ISPSCHEDMODE_NONE (0)
#define ROGUE_FWIF_INICFG_ISPSCHEDMODE_VER1_IPP \
 (ROGUE_FWIF_ISP_SCHEDMODE_VER1_IPP      \
  << ROGUE_FWIF_INICFG_ISPSCHEDMODE_SHIFT)
#define ROGUE_FWIF_INICFG_ISPSCHEDMODE_VER2_ISP \
 (ROGUE_FWIF_ISP_SCHEDMODE_VER2_ISP      \
  << ROGUE_FWIF_INICFG_ISPSCHEDMODE_SHIFT)
#define ROGUE_FWIF_INICFG_ISPSCHEDMODE_MASK        \
 (ROGUE_FWIF_INICFG_ISPSCHEDMODE_VER1_IPP | \
  ROGUE_FWIF_INICFG_ISPSCHEDMODE_VER2_ISP)
#define ROGUE_FWIF_INICFG_VALIDATE_SOCUSC_TIMER BIT(31)

#define ROGUE_FWIF_INICFG_ALL (0xFFFFFFFFU)

/* Extended Flag definitions affecting the firmware globally */
#define ROGUE_FWIF_INICFG_EXT_TFBC_CONTROL_SHIFT (0)
/* [7]   YUV10 override
 * [6:4] Quality
 * [3]   Quality enable
 * [2:1] Compression scheme
 * [0]   Lossy group
 */
#define ROGUE_FWIF_INICFG_EXT_TFBC_CONTROL_MASK (0xFF)
#define ROGUE_FWIF_INICFG_EXT_ALL (ROGUE_FWIF_INICFG_EXT_TFBC_CONTROL_MASK)

/* Flag definitions affecting only workloads submitted by a particular OS */
#define ROGUE_FWIF_INICFG_OS_CTXSWITCH_TDM_EN BIT(0)
#define ROGUE_FWIF_INICFG_OS_CTXSWITCH_GEOM_EN BIT(1)
#define ROGUE_FWIF_INICFG_OS_CTXSWITCH_FRAG_EN BIT(2)
#define ROGUE_FWIF_INICFG_OS_CTXSWITCH_CDM_EN BIT(3)

#define ROGUE_FWIF_INICFG_OS_LOW_PRIO_CS_TDM BIT(4)
#define ROGUE_FWIF_INICFG_OS_LOW_PRIO_CS_GEOM BIT(5)
#define ROGUE_FWIF_INICFG_OS_LOW_PRIO_CS_FRAG BIT(6)
#define ROGUE_FWIF_INICFG_OS_LOW_PRIO_CS_CDM BIT(7)

#define ROGUE_FWIF_INICFG_OS_ALL (0xFF)

#define ROGUE_FWIF_INICFG_OS_CTXSWITCH_DM_ALL     \
 (ROGUE_FWIF_INICFG_OS_CTXSWITCH_TDM_EN |  \
  ROGUE_FWIF_INICFG_OS_CTXSWITCH_GEOM_EN | \
  ROGUE_FWIF_INICFG_OS_CTXSWITCH_FRAG_EN |   \
  ROGUE_FWIF_INICFG_OS_CTXSWITCH_CDM_EN)

#define ROGUE_FWIF_INICFG_OS_CTXSWITCH_CLRMSK \
 ~(ROGUE_FWIF_INICFG_OS_CTXSWITCH_DM_ALL)

#define ROGUE_FWIF_FILTCFG_TRUNCATE_HALF BIT(3)
#define ROGUE_FWIF_FILTCFG_TRUNCATE_INT BIT(2)
#define ROGUE_FWIF_FILTCFG_NEW_FILTER_MODE BIT(1)

enum rogue_activepm_conf {
 ROGUE_ACTIVEPM_FORCE_OFF = 0,
 ROGUE_ACTIVEPM_FORCE_ON = 1,
 ROGUE_ACTIVEPM_DEFAULT = 2
};

enum rogue_rd_power_island_conf {
 ROGUE_RD_POWER_ISLAND_FORCE_OFF = 0,
 ROGUE_RD_POWER_ISLAND_FORCE_ON = 1,
 ROGUE_RD_POWER_ISLAND_DEFAULT = 2
};

struct rogue_fw_register_list {
 /* Register number */
 u16 reg_num;
 /* Indirect register number (or 0 if not used) */
 u16 indirect_reg_num;
 /* Start value for indirect register */
 u16 indirect_start_val;
 /* End value for indirect register */
 u16 indirect_end_val;
};

struct rogue_fwif_dllist_node {
 u32 p;
 u32 n;
};

/*
 * This number is used to represent an invalid page catalogue physical address
 */
#define ROGUE_FWIF_INVALID_PC_PHYADDR 0xFFFFFFFFFFFFFFFFLLU

/* This number is used to represent unallocated page catalog base register */
#define ROGUE_FW_BIF_INVALID_PCSET 0xFFFFFFFFU

/* Firmware memory context. */
struct rogue_fwif_fwmemcontext {
 /* device physical address of context's page catalogue */
 aligned_u64 pc_dev_paddr;
 /*
 * associated page catalog base register (ROGUE_FW_BIF_INVALID_PCSET ==
 * unallocated)
 */
 u32 page_cat_base_reg_set;
 /* breakpoint address */
 u32 breakpoint_addr;
 /* breakpoint handler address */
 u32 bp_handler_addr;
 /* DM and enable control for BP */
 u32 breakpoint_ctl;
 /* Compatibility and other flags */
 u32 fw_mem_ctx_flags;
 u32 padding;
} __aligned(8);

/*
 * FW context state flags
 */
#define ROGUE_FWIF_CONTEXT_FLAGS_NEED_RESUME (0x00000001U)
#define ROGUE_FWIF_CONTEXT_FLAGS_MC_NEED_RESUME_MASKFULL (0x000000FFU)
#define ROGUE_FWIF_CONTEXT_FLAGS_TDM_HEADER_STALE (0x00000100U)
#define ROGUE_FWIF_CONTEXT_FLAGS_LAST_KICK_SECURE (0x00000200U)

#define ROGUE_NUM_GEOM_CORES_MAX 4

/*
 * FW-accessible TA state which must be written out to memory on context store
 */
struct rogue_fwif_geom_ctx_state_per_geom {
 /* To store in mid-TA */
 aligned_u64 geom_reg_vdm_call_stack_pointer;
 /* Initial value (in case is 'lost' due to a lock-up */
 aligned_u64 geom_reg_vdm_call_stack_pointer_init;
 u32 geom_reg_vbs_so_prim[4];
 u16 geom_current_idx;
 u16 padding[3];
} __aligned(8);

struct rogue_fwif_geom_ctx_state {
 /* FW-accessible TA state which must be written out to memory on context store */
 struct rogue_fwif_geom_ctx_state_per_geom geom_core[ROGUE_NUM_GEOM_CORES_MAX];
} __aligned(8);

/*
 * FW-accessible ISP state which must be written out to memory on context store
 */
struct rogue_fwif_frag_ctx_state {
 u32 frag_reg_pm_deallocated_mask_status;
 u32 frag_reg_dm_pds_mtilefree_status;
 /* Compatibility and other flags */
 u32 ctx_state_flags;
 /*
 * frag_reg_isp_store should be the last element of the structure as this
 * is an array whose size is determined at runtime after detecting the
 * ROGUE core
 */
 u32 frag_reg_isp_store[];
} __aligned(8);

#define ROGUE_FWIF_CTX_USING_BUFFER_A (0)
#define ROGUE_FWIF_CTX_USING_BUFFER_B (1U)

struct rogue_fwif_compute_ctx_state {
 u32 ctx_state_flags; /* Target buffer and other flags */
};

struct rogue_fwif_fwcommoncontext {
 /* CCB details for this firmware context */
 u32 ccbctl_fw_addr; /* CCB control */
 u32 ccb_fw_addr; /* CCB base */
 struct rogue_fwif_dma_addr ccb_meta_dma_addr;

 /* Context suspend state */
 /* geom/frag context suspend state, read/written by FW */
 u32 context_state_addr __aligned(8);

 /* Flags e.g. for context switching */
 u32 fw_com_ctx_flags;
 u32 priority;
 u32 priority_seq_num;

 /* Framework state */
 /* Register updates for Framework */
 u32 rf_cmd_addr __aligned(8);

 /* Statistic updates waiting to be passed back to the host... */
 /* True when some stats are pending */
 bool stats_pending __aligned(4);
 /* Number of stores on this context since last update */
 s32 stats_num_stores;
 /* Number of OOMs on this context since last update */
 s32 stats_num_out_of_memory;
 /* Number of PRs on this context since last update */
 s32 stats_num_partial_renders;
 /* Data Master type */
 u32 dm;
 /* Device Virtual Address of the signal the context is waiting on */
 aligned_u64 wait_signal_address;
 /* List entry for the wait-signal list */
 struct rogue_fwif_dllist_node wait_signal_node __aligned(8);
 /* List entry for the buffer stalled list */
 struct rogue_fwif_dllist_node buf_stalled_node __aligned(8);
 /* Address of the circular buffer queue pointers */
 aligned_u64 cbuf_queue_ctrl_addr;

 aligned_u64 robustness_address;
 /* Max HWR deadline limit in ms */
 u32 max_deadline_ms;
 /* Following HWR circular buffer read-offset needs resetting */
 bool read_offset_needs_reset;

 /* List entry for the waiting list */
 struct rogue_fwif_dllist_node waiting_node __aligned(8);
 /* List entry for the run list */
 struct rogue_fwif_dllist_node run_node __aligned(8);
 /* UFO that last failed (or NULL) */
 struct rogue_fwif_ufo last_failed_ufo;

 /* Memory context */
 u32 fw_mem_context_fw_addr;

 /* References to the host side originators */
 /* the Server Common Context */
 u32 server_common_context_id;
 /* associated process ID */
 u32 pid;

 /* True when Geom DM OOM is not allowed */
 bool geom_oom_disabled __aligned(4);
} __aligned(8);

/* Firmware render context. */
struct rogue_fwif_fwrendercontext {
 /* Geometry firmware context. */
 struct rogue_fwif_fwcommoncontext geom_context;
 /* Fragment firmware context. */
 struct rogue_fwif_fwcommoncontext frag_context;

 struct rogue_fwif_static_rendercontext_state static_render_context_state;

 /* Number of commands submitted to the WorkEst FW CCB */
 u32 work_est_ccb_submitted;

 /* Compatibility and other flags */
 u32 fw_render_ctx_flags;
} __aligned(8);

/* Firmware compute context. */
struct rogue_fwif_fwcomputecontext {
 /* Firmware context for the CDM */
 struct rogue_fwif_fwcommoncontext cdm_context;

 struct rogue_fwif_static_computecontext_state
  static_compute_context_state;

 /* Number of commands submitted to the WorkEst FW CCB */
 u32 work_est_ccb_submitted;

 /* Compatibility and other flags */
 u32 compute_ctx_flags;

 u32 wgp_state;
 u32 wgp_checksum;
 u32 core_mask_a;
 u32 core_mask_b;
} __aligned(8);

/* Firmware TDM context. */
struct rogue_fwif_fwtdmcontext {
 /* Firmware context for the TDM */
 struct rogue_fwif_fwcommoncontext tdm_context;

 /* Number of commands submitted to the WorkEst FW CCB */
 u32 work_est_ccb_submitted;
} __aligned(8);

/* Firmware TQ3D context. */
struct rogue_fwif_fwtransfercontext {
 /* Firmware context for TQ3D. */
 struct rogue_fwif_fwcommoncontext tq_context;
} __aligned(8);

/*
 ******************************************************************************
 * Defines for CMD_TYPE corruption detection and forward compatibility check
 ******************************************************************************
 */

/*
 * CMD_TYPE 32bit contains:
 * 31:16 Reserved for magic value to detect corruption (16 bits)
 * 15 Reserved for ROGUE_CCB_TYPE_TASK (1 bit)
 * 14:0 Bits available for CMD_TYPEs (15 bits)
 */

/* Magic value to detect corruption */
#define ROGUE_CMD_MAGIC_DWORD (0x2ABC)
#define ROGUE_CMD_MAGIC_DWORD_MASK (0xFFFF0000U)
#define ROGUE_CMD_MAGIC_DWORD_SHIFT (16U)
#define ROGUE_CMD_MAGIC_DWORD_SHIFTED \
 (ROGUE_CMD_MAGIC_DWORD << ROGUE_CMD_MAGIC_DWORD_SHIFT)

/* Kernel CCB control for ROGUE */
struct rogue_fwif_ccb_ctl {
 /* write offset into array of commands (MUST be aligned to 16 bytes!) */
 u32 write_offset;
 /* Padding to ensure read and write offsets are in separate cache lines. */
 u8 padding[128 - sizeof(u32)];
 /* read offset into array of commands */
 u32 read_offset;
 /* Offset wrapping mask (Total capacity of the CCB - 1) */
 u32 wrap_mask;
 /* size of each command in bytes */
 u32 cmd_size;
 u32 padding2;
} __aligned(8);

/* Kernel CCB command structure for ROGUE */

#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_PT (0x1U) /* MMU_CTRL_INVAL_PT_EN */
#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_PD (0x2U) /* MMU_CTRL_INVAL_PD_EN */
#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_PC (0x4U) /* MMU_CTRL_INVAL_PC_EN */

/*
 * can't use PM_TLB0 bit from BIFPM_CTRL reg because it collides with PT
 * bit from BIF_CTRL reg
 */
#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_PMTLB (0x10)
/* BIF_CTRL_INVAL_TLB1_EN */
#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_TLB \
 (ROGUE_FWIF_MMUCACHEDATA_FLAGS_PMTLB | 0x8)
/* MMU_CTRL_INVAL_ALL_CONTEXTS_EN */
#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_CTX_ALL (0x800)

/* indicates FW should interrupt the host */
#define ROGUE_FWIF_MMUCACHEDATA_FLAGS_INTERRUPT (0x4000000U)

struct rogue_fwif_mmucachedata {
 u32 cache_flags;
 u32 mmu_cache_sync_fw_addr;
 u32 mmu_cache_sync_update_value;
};

#define ROGUE_FWIF_BPDATA_FLAGS_ENABLE BIT(0)
#define ROGUE_FWIF_BPDATA_FLAGS_WRITE BIT(1)
#define ROGUE_FWIF_BPDATA_FLAGS_CTL BIT(2)
#define ROGUE_FWIF_BPDATA_FLAGS_REGS BIT(3)

struct rogue_fwif_bpdata {
 /* Memory context */
 u32 fw_mem_context_fw_addr;
 /* Breakpoint address */
 u32 bp_addr;
 /* Breakpoint handler */
 u32 bp_handler_addr;
 /* Breakpoint control */
 u32 bp_dm;
 u32 bp_data_flags;
 /* Number of temporary registers to overallocate */
 u32 temp_regs;
 /* Number of shared registers to overallocate */
 u32 shared_regs;
 /* DM associated with the breakpoint */
 u32 dm;
};

#define ROGUE_FWIF_KCCB_CMD_KICK_DATA_MAX_NUM_CLEANUP_CTLS \
 (ROGUE_FWIF_PRBUFFER_MAXSUPPORTED + 1U) /* +1 is RTDATASET cleanup */

struct rogue_fwif_kccb_cmd_kick_data {
 /* address of the firmware context */
 u32 context_fw_addr;
 /* Client CCB woff update */
 u32 client_woff_update;
 /* Client CCB wrap mask update after CCCB growth */
 u32 client_wrap_mask_update;
 /* number of CleanupCtl pointers attached */
 u32 num_cleanup_ctl;
 /* CleanupCtl structures associated with command */
 u32 cleanup_ctl_fw_addr
  [ROGUE_FWIF_KCCB_CMD_KICK_DATA_MAX_NUM_CLEANUP_CTLS];
 /*
 * offset to the CmdHeader which houses the workload estimation kick
 * data.
 */
 u32 work_est_cmd_header_offset;
};

struct rogue_fwif_kccb_cmd_combined_geom_frag_kick_data {
 struct rogue_fwif_kccb_cmd_kick_data geom_cmd_kick_data;
 struct rogue_fwif_kccb_cmd_kick_data frag_cmd_kick_data;
};

struct rogue_fwif_kccb_cmd_force_update_data {
 /* address of the firmware context */
 u32 context_fw_addr;
 /* Client CCB fence offset */
 u32 ccb_fence_offset;
};

enum rogue_fwif_cleanup_type {
 /* FW common context cleanup */
 ROGUE_FWIF_CLEANUP_FWCOMMONCONTEXT,
 /* FW HW RT data cleanup */
 ROGUE_FWIF_CLEANUP_HWRTDATA,
 /* FW freelist cleanup */
 ROGUE_FWIF_CLEANUP_FREELIST,
 /* FW ZS Buffer cleanup */
 ROGUE_FWIF_CLEANUP_ZSBUFFER,
};

struct rogue_fwif_cleanup_request {
 /* Cleanup type */
 enum rogue_fwif_cleanup_type cleanup_type;
 union {
  /* FW common context to cleanup */
  u32 context_fw_addr;
  /* HW RT to cleanup */
  u32 hwrt_data_fw_addr;
  /* Freelist to cleanup */
  u32 freelist_fw_addr;
  /* ZS Buffer to cleanup */
  u32 zs_buffer_fw_addr;
 } cleanup_data;
};

enum rogue_fwif_power_type {
 ROGUE_FWIF_POW_OFF_REQ = 1,
 ROGUE_FWIF_POW_FORCED_IDLE_REQ,
 ROGUE_FWIF_POW_NUM_UNITS_CHANGE,
 ROGUE_FWIF_POW_APM_LATENCY_CHANGE
};

enum rogue_fwif_power_force_idle_type {
 ROGUE_FWIF_POWER_FORCE_IDLE = 1,
 ROGUE_FWIF_POWER_CANCEL_FORCED_IDLE,
 ROGUE_FWIF_POWER_HOST_TIMEOUT,
};

struct rogue_fwif_power_request {
 /* Type of power request */
 enum rogue_fwif_power_type pow_type;
 union {
  /* Number of active Dusts */
  u32 num_of_dusts;
  /* If the operation is mandatory */
  bool forced __aligned(4);
  /*
 * Type of Request. Consolidating Force Idle, Cancel Forced
 * Idle, Host Timeout
 */
  enum rogue_fwif_power_force_idle_type pow_request_type;
 } power_req_data;
};

struct rogue_fwif_slcflushinvaldata {
 /* Context to fence on (only useful when bDMContext == TRUE) */
 u32 context_fw_addr;
 /* Invalidate the cache as well as flushing */
 bool inval __aligned(4);
 /* The data to flush/invalidate belongs to a specific DM context */
 bool dm_context __aligned(4);
 /* Optional address of range (only useful when bDMContext == FALSE) */
 aligned_u64 address;
 /* Optional size of range (only useful when bDMContext == FALSE) */
 aligned_u64 size;
};

enum rogue_fwif_hwperf_update_config {
 ROGUE_FWIF_HWPERF_CTRL_TOGGLE = 0,
 ROGUE_FWIF_HWPERF_CTRL_SET = 1,
 ROGUE_FWIF_HWPERF_CTRL_EMIT_FEATURES_EV = 2
};

struct rogue_fwif_hwperf_ctrl {
 enum rogue_fwif_hwperf_update_config opcode; /* Control operation code */
 aligned_u64 mask; /* Mask of events to toggle */
};

struct rogue_fwif_hwperf_config_enable_blks {
 /* Number of ROGUE_HWPERF_CONFIG_MUX_CNTBLK in the array */
 u32 num_blocks;
 /* Address of the ROGUE_HWPERF_CONFIG_MUX_CNTBLK array */
 u32 block_configs_fw_addr;
};

struct rogue_fwif_hwperf_config_da_blks {
 /* Number of ROGUE_HWPERF_CONFIG_CNTBLK in the array */
 u32 num_blocks;
 /* Address of the ROGUE_HWPERF_CONFIG_CNTBLK array */
 u32 block_configs_fw_addr;
};

struct rogue_fwif_coreclkspeedchange_data {
 u32 new_clock_speed; /* New clock speed */
};

#define ROGUE_FWIF_HWPERF_CTRL_BLKS_MAX 16

struct rogue_fwif_hwperf_ctrl_blks {
 bool enable;
 /* Number of block IDs in the array */
 u32 num_blocks;
 /* Array of ROGUE_HWPERF_CNTBLK_ID values */
 u16 block_ids[ROGUE_FWIF_HWPERF_CTRL_BLKS_MAX];
};

struct rogue_fwif_hwperf_select_custom_cntrs {
 u16 custom_block;
 u16 num_counters;
 u32 custom_counter_ids_fw_addr;
};

struct rogue_fwif_zsbuffer_backing_data {
 u32 zs_buffer_fw_addr; /* ZS-Buffer FW address */

 bool done __aligned(4); /* action backing/unbacking succeeded */
};

struct rogue_fwif_freelist_gs_data {
 /* Freelist FW address */
 u32 freelist_fw_addr;
 /* Amount of the Freelist change */
 u32 delta_pages;
 /* New amount of pages on the freelist (including ready pages) */
 u32 new_pages;
 /* Number of ready pages to be held in reserve until OOM */
 u32 ready_pages;
};

#define MAX_FREELISTS_SIZE 3
#define MAX_HW_GEOM_FRAG_CONTEXTS_SIZE 3

#define ROGUE_FWIF_MAX_FREELISTS_TO_RECONSTRUCT \
 (MAX_HW_GEOM_FRAG_CONTEXTS_SIZE * MAX_FREELISTS_SIZE * 2U)
#define ROGUE_FWIF_FREELISTS_RECONSTRUCTION_FAILED_FLAG 0x80000000U

struct rogue_fwif_freelists_reconstruction_data {
 u32 freelist_count;
 u32 freelist_ids[ROGUE_FWIF_MAX_FREELISTS_TO_RECONSTRUCT];
};

struct rogue_fwif_write_offset_update_data {
 /*
 * Context to that may need to be resumed following write offset update
 */
 u32 context_fw_addr;
} __aligned(8);

/*
 ******************************************************************************
 * Proactive DVFS Structures
 ******************************************************************************
 */
#define NUM_OPP_VALUES 16

struct pdvfs_opp {
 u32 volt; /* V  */
 u32 freq; /* Hz */
} __aligned(8);

struct rogue_fwif_pdvfs_opp {
 struct pdvfs_opp opp_values[NUM_OPP_VALUES];
 u32 min_opp_point;
 u32 max_opp_point;
} __aligned(8);

struct rogue_fwif_pdvfs_max_freq_data {
 u32 max_opp_point;
} __aligned(8);

struct rogue_fwif_pdvfs_min_freq_data {
 u32 min_opp_point;
} __aligned(8);

/*
 ******************************************************************************
 * Register configuration structures
 ******************************************************************************
 */

#define ROGUE_FWIF_REG_CFG_MAX_SIZE 512

enum rogue_fwif_regdata_cmd_type {
 ROGUE_FWIF_REGCFG_CMD_ADD = 101,
 ROGUE_FWIF_REGCFG_CMD_CLEAR = 102,
 ROGUE_FWIF_REGCFG_CMD_ENABLE = 103,
 ROGUE_FWIF_REGCFG_CMD_DISABLE = 104
};

enum rogue_fwif_reg_cfg_type {
 /* Sidekick power event */
 ROGUE_FWIF_REG_CFG_TYPE_PWR_ON = 0,
 /* Rascal / dust power event */
 ROGUE_FWIF_REG_CFG_TYPE_DUST_CHANGE,
 /* Geometry kick */
 ROGUE_FWIF_REG_CFG_TYPE_GEOM,
 /* Fragment kick */
 ROGUE_FWIF_REG_CFG_TYPE_FRAG,
 /* Compute kick */
 ROGUE_FWIF_REG_CFG_TYPE_CDM,
 /* TLA kick */
 ROGUE_FWIF_REG_CFG_TYPE_TLA,
 /* TDM kick */
 ROGUE_FWIF_REG_CFG_TYPE_TDM,
 /* Applies to all types. Keep as last element */
 ROGUE_FWIF_REG_CFG_TYPE_ALL
};

struct rogue_fwif_reg_cfg_rec {
 u64 sddr;
 u64 mask;
 u64 value;
};

struct rogue_fwif_regconfig_data {
 enum rogue_fwif_regdata_cmd_type cmd_type;
 enum rogue_fwif_reg_cfg_type reg_config_type;
 struct rogue_fwif_reg_cfg_rec reg_config __aligned(8);
};

struct rogue_fwif_reg_cfg {
 /*
 * PDump WRW command write granularity is 32 bits.
 * Add padding to ensure array size is 32 bit granular.
 */
 u8 num_regs_type[ALIGN((u32)ROGUE_FWIF_REG_CFG_TYPE_ALL,
          sizeof(u32))] __aligned(8);
 struct rogue_fwif_reg_cfg_rec
  reg_configs[ROGUE_FWIF_REG_CFG_MAX_SIZE] __aligned(8);
} __aligned(8);

enum rogue_fwif_os_state_change {
 ROGUE_FWIF_OS_ONLINE = 1,
 ROGUE_FWIF_OS_OFFLINE
};

struct rogue_fwif_os_state_change_data {
 u32 osid;
 enum rogue_fwif_os_state_change new_os_state;
} __aligned(8);

enum rogue_fwif_counter_dump_request {
 ROGUE_FWIF_PWR_COUNTER_DUMP_START = 1,
 ROGUE_FWIF_PWR_COUNTER_DUMP_STOP,
 ROGUE_FWIF_PWR_COUNTER_DUMP_SAMPLE,
};

struct rogue_fwif_counter_dump_data {
 enum rogue_fwif_counter_dump_request counter_dump_request;
} __aligned(8);

enum rogue_fwif_kccb_cmd_type {
 /* Common commands */
 ROGUE_FWIF_KCCB_CMD_KICK = 101U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 ROGUE_FWIF_KCCB_CMD_MMUCACHE = 102U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 ROGUE_FWIF_KCCB_CMD_BP = 103U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* SLC flush and invalidation request */
 ROGUE_FWIF_KCCB_CMD_SLCFLUSHINVAL = 105U |
         ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /*
 * Requests cleanup of a FW resource (type specified in the command
 * data)
 */
 ROGUE_FWIF_KCCB_CMD_CLEANUP = 106U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Power request */
 ROGUE_FWIF_KCCB_CMD_POW = 107U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Backing for on-demand ZS-Buffer done */
 ROGUE_FWIF_KCCB_CMD_ZSBUFFER_BACKING_UPDATE =
  108U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Unbacking for on-demand ZS-Buffer done */
 ROGUE_FWIF_KCCB_CMD_ZSBUFFER_UNBACKING_UPDATE =
  109U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Freelist Grow done */
 ROGUE_FWIF_KCCB_CMD_FREELIST_GROW_UPDATE =
  110U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Freelists Reconstruction done */
 ROGUE_FWIF_KCCB_CMD_FREELISTS_RECONSTRUCTION_UPDATE =
  112U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /*
 * Informs the firmware that the host has added more data to a CDM2
 * Circular Buffer
 */
 ROGUE_FWIF_KCCB_CMD_NOTIFY_WRITE_OFFSET_UPDATE =
  114U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Health check request */
 ROGUE_FWIF_KCCB_CMD_HEALTH_CHECK = 115U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Forcing signalling of all unmet UFOs for a given CCB offset */
 ROGUE_FWIF_KCCB_CMD_FORCE_UPDATE = 116U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* There is a geometry and a fragment command in this single kick */
 ROGUE_FWIF_KCCB_CMD_COMBINED_GEOM_FRAG_KICK = 117U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Informs the FW that a Guest OS has come online / offline. */
 ROGUE_FWIF_KCCB_CMD_OS_ONLINE_STATE_CONFIGURE = 118U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Commands only permitted to the native or host OS */
 ROGUE_FWIF_KCCB_CMD_REGCONFIG = 200U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Configure HWPerf events (to be generated) and HWPerf buffer address (if required) */
 ROGUE_FWIF_KCCB_CMD_HWPERF_UPDATE_CONFIG = 201U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Enable or disable multiple HWPerf blocks (reusing existing configuration) */
 ROGUE_FWIF_KCCB_CMD_HWPERF_CTRL_BLKS = 203U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Core clock speed change event */
 ROGUE_FWIF_KCCB_CMD_CORECLKSPEEDCHANGE = 204U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /*
 * Ask the firmware to update its cached ui32LogType value from the (shared)
 * tracebuf control structure
 */
 ROGUE_FWIF_KCCB_CMD_LOGTYPE_UPDATE = 206U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Set a maximum frequency/OPP point */
 ROGUE_FWIF_KCCB_CMD_PDVFS_LIMIT_MAX_FREQ = 207U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /*
 * Changes the relative scheduling priority for a particular OSid. It can
 * only be serviced for the Host DDK
 */
 ROGUE_FWIF_KCCB_CMD_OSID_PRIORITY_CHANGE = 208U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Set or clear firmware state flags */
 ROGUE_FWIF_KCCB_CMD_STATEFLAGS_CTRL = 209U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Set a minimum frequency/OPP point */
 ROGUE_FWIF_KCCB_CMD_PDVFS_LIMIT_MIN_FREQ = 212U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Configure Periodic Hardware Reset behaviour */
 ROGUE_FWIF_KCCB_CMD_PHR_CFG = 213U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Configure Safety Firmware Watchdog */
 ROGUE_FWIF_KCCB_CMD_WDG_CFG = 215U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Controls counter dumping in the FW */
 ROGUE_FWIF_KCCB_CMD_COUNTER_DUMP = 216U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Configure, clear and enable multiple HWPerf blocks */
 ROGUE_FWIF_KCCB_CMD_HWPERF_CONFIG_ENABLE_BLKS = 217U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Configure the custom counters for HWPerf */
 ROGUE_FWIF_KCCB_CMD_HWPERF_SELECT_CUSTOM_CNTRS = 218U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Configure directly addressable counters for HWPerf */
 ROGUE_FWIF_KCCB_CMD_HWPERF_CONFIG_BLKS = 220U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
};

#define ROGUE_FWIF_LAST_ALLOWED_GUEST_KCCB_CMD \
 (ROGUE_FWIF_KCCB_CMD_REGCONFIG - 1)

/* Kernel CCB command packet */
struct rogue_fwif_kccb_cmd {
 /* Command type */
 enum rogue_fwif_kccb_cmd_type cmd_type;
 /* Compatibility and other flags */
 u32 kccb_flags;

 /*
 * NOTE: Make sure that uCmdData is the last member of this struct
 * This is to calculate actual command size for device mem copy.
 * (Refer ROGUEGetCmdMemCopySize())
 */
 union {
  /* Data for Kick command */
  struct rogue_fwif_kccb_cmd_kick_data cmd_kick_data;
  /* Data for combined geom/frag Kick command */
  struct rogue_fwif_kccb_cmd_combined_geom_frag_kick_data
   combined_geom_frag_cmd_kick_data;
  /* Data for MMU cache command */
  struct rogue_fwif_mmucachedata mmu_cache_data;
  /* Data for Breakpoint Commands */
  struct rogue_fwif_bpdata bp_data;
  /* Data for SLC Flush/Inval commands */
  struct rogue_fwif_slcflushinvaldata slc_flush_inval_data;
  /* Data for cleanup commands */
  struct rogue_fwif_cleanup_request cleanup_data;
  /* Data for power request commands */
  struct rogue_fwif_power_request pow_data;
  /* Data for HWPerf control command */
  struct rogue_fwif_hwperf_ctrl hw_perf_ctrl;
  /*
 * Data for HWPerf configure, clear and enable performance
 * counter block command
 */
  struct rogue_fwif_hwperf_config_enable_blks
   hw_perf_cfg_enable_blks;
  /*
 * Data for HWPerf enable or disable performance counter block
 * commands
 */
  struct rogue_fwif_hwperf_ctrl_blks hw_perf_ctrl_blks;
  /* Data for HWPerf configure the custom counters to read */
  struct rogue_fwif_hwperf_select_custom_cntrs
   hw_perf_select_cstm_cntrs;
  /* Data for HWPerf configure Directly Addressable blocks */
  struct rogue_fwif_hwperf_config_da_blks hw_perf_cfg_da_blks;
  /* Data for core clock speed change */
  struct rogue_fwif_coreclkspeedchange_data
   core_clk_speed_change_data;
  /* Feedback for Z/S Buffer backing/unbacking */
  struct rogue_fwif_zsbuffer_backing_data zs_buffer_backing_data;
  /* Feedback for Freelist grow/shrink */
  struct rogue_fwif_freelist_gs_data free_list_gs_data;
  /* Feedback for Freelists reconstruction*/
  struct rogue_fwif_freelists_reconstruction_data
   free_lists_reconstruction_data;
  /* Data for custom register configuration */
  struct rogue_fwif_regconfig_data reg_config_data;
  /* Data for informing the FW about the write offset update */
  struct rogue_fwif_write_offset_update_data
   write_offset_update_data;
  /* Data for setting the max frequency/OPP */
  struct rogue_fwif_pdvfs_max_freq_data pdvfs_max_freq_data;
  /* Data for setting the min frequency/OPP */
  struct rogue_fwif_pdvfs_min_freq_data pdvfs_min_freq_data;
  /* Data for updating the Guest Online states */
  struct rogue_fwif_os_state_change_data cmd_os_online_state_data;
  /* Dev address for TBI buffer allocated on demand */
  u32 tbi_buffer_fw_addr;
  /* Data for dumping of register ranges */
  struct rogue_fwif_counter_dump_data counter_dump_config_data;
  /* Data for signalling all unmet fences for a given CCB */
  struct rogue_fwif_kccb_cmd_force_update_data force_update_data;
 } cmd_data __aligned(8);
} __aligned(8);

PVR_FW_STRUCT_SIZE_ASSERT(struct rogue_fwif_kccb_cmd);

/*
 ******************************************************************************
 * Firmware CCB command structure for ROGUE
 ******************************************************************************
 */

struct rogue_fwif_fwccb_cmd_zsbuffer_backing_data {
 u32 zs_buffer_id;
};

struct rogue_fwif_fwccb_cmd_freelist_gs_data {
 u32 freelist_id;
};

struct rogue_fwif_fwccb_cmd_freelists_reconstruction_data {
 u32 freelist_count;
 u32 hwr_counter;
 u32 freelist_ids[ROGUE_FWIF_MAX_FREELISTS_TO_RECONSTRUCT];
};

/* 1 if a page fault happened */
#define ROGUE_FWIF_FWCCB_CMD_CONTEXT_RESET_FLAG_PF BIT(0)
/* 1 if applicable to all contexts */
#define ROGUE_FWIF_FWCCB_CMD_CONTEXT_RESET_FLAG_ALL_CTXS BIT(1)

struct rogue_fwif_fwccb_cmd_context_reset_data {
 /* Context affected by the reset */
 u32 server_common_context_id;
 /* Reason for reset */
 enum rogue_context_reset_reason reset_reason;
 /* Data Master affected by the reset */
 u32 dm;
 /* Job ref running at the time of reset */
 u32 reset_job_ref;
 /* ROGUE_FWIF_FWCCB_CMD_CONTEXT_RESET_FLAG bitfield */
 u32 flags;
 /* At what page catalog address */
 aligned_u64 pc_address;
 /* Page fault address (only when applicable) */
 aligned_u64 fault_address;
};

struct rogue_fwif_fwccb_cmd_fw_pagefault_data {
 /* Page fault address */
 u64 fw_fault_addr;
};

enum rogue_fwif_fwccb_cmd_type {
 /* Requests ZSBuffer to be backed with physical pages */
 ROGUE_FWIF_FWCCB_CMD_ZSBUFFER_BACKING = 101U |
      ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Requests ZSBuffer to be unbacked */
 ROGUE_FWIF_FWCCB_CMD_ZSBUFFER_UNBACKING = 102U |
        ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Requests an on-demand freelist grow/shrink */
 ROGUE_FWIF_FWCCB_CMD_FREELIST_GROW = 103U |
          ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Requests freelists reconstruction */
 ROGUE_FWIF_FWCCB_CMD_FREELISTS_RECONSTRUCTION =
  104U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Notifies host of a HWR event on a context */
 ROGUE_FWIF_FWCCB_CMD_CONTEXT_RESET_NOTIFICATION =
  105U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Requests an on-demand debug dump */
 ROGUE_FWIF_FWCCB_CMD_DEBUG_DUMP = 106U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 /* Requests an on-demand update on process stats */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_STATS = 107U |
         ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 ROGUE_FWIF_FWCCB_CMD_CORE_CLK_RATE_CHANGE =
  108U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
 ROGUE_FWIF_FWCCB_CMD_REQUEST_GPU_RESTART =
  109U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,

 /* Notifies host of a FW pagefault */
 ROGUE_FWIF_FWCCB_CMD_CONTEXT_FW_PF_NOTIFICATION =
  112U | ROGUE_CMD_MAGIC_DWORD_SHIFTED,
};

enum rogue_fwif_fwccb_cmd_update_stats_type {
 /*
 * PVRSRVStatsUpdateRenderContextStats should increase the value of the
 * ui32TotalNumPartialRenders stat
 */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_NUM_PARTIAL_RENDERS = 1,
 /*
 * PVRSRVStatsUpdateRenderContextStats should increase the value of the
 * ui32TotalNumOutOfMemory stat
 */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_NUM_OUT_OF_MEMORY,
 /*
 * PVRSRVStatsUpdateRenderContextStats should increase the value of the
 * ui32NumGeomStores stat
 */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_NUM_GEOM_STORES,
 /*
 * PVRSRVStatsUpdateRenderContextStats should increase the value of the
 * ui32NumFragStores stat
 */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_NUM_FRAG_STORES,
 /*
 * PVRSRVStatsUpdateRenderContextStats should increase the value of the
 * ui32NumCDMStores stat
 */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_NUM_CDM_STORES,
 /*
 * PVRSRVStatsUpdateRenderContextStats should increase the value of the
 * ui32NumTDMStores stat
 */
 ROGUE_FWIF_FWCCB_CMD_UPDATE_NUM_TDM_STORES
};

struct rogue_fwif_fwccb_cmd_update_stats_data {
 /* Element to update */
 enum rogue_fwif_fwccb_cmd_update_stats_type element_to_update;
 /* The pid of the process whose stats are being updated */
 u32 pid_owner;
 /* Adjustment to be made to the statistic */
 s32 adjustment_value;
};

struct rogue_fwif_fwccb_cmd_core_clk_rate_change_data {
 u32 core_clk_rate;
} __aligned(8);

struct rogue_fwif_fwccb_cmd {
 /* Command type */
 enum rogue_fwif_fwccb_cmd_type cmd_type;
 /* Compatibility and other flags */
 u32 fwccb_flags;

 union {
  /* Data for Z/S-Buffer on-demand (un)backing*/
  struct rogue_fwif_fwccb_cmd_zsbuffer_backing_data
   cmd_zs_buffer_backing;
  /* Data for on-demand freelist grow/shrink */
  struct rogue_fwif_fwccb_cmd_freelist_gs_data cmd_free_list_gs;
  /* Data for freelists reconstruction */
  struct rogue_fwif_fwccb_cmd_freelists_reconstruction_data
   cmd_freelists_reconstruction;
  /* Data for context reset notification */
  struct rogue_fwif_fwccb_cmd_context_reset_data
   cmd_context_reset_notification;
  /* Data for updating process stats */
  struct rogue_fwif_fwccb_cmd_update_stats_data
   cmd_update_stats_data;
  struct rogue_fwif_fwccb_cmd_core_clk_rate_change_data
   cmd_core_clk_rate_change;
  struct rogue_fwif_fwccb_cmd_fw_pagefault_data cmd_fw_pagefault;
 } cmd_data __aligned(8);
} __aligned(8);

PVR_FW_STRUCT_SIZE_ASSERT(struct rogue_fwif_fwccb_cmd);

/*
 ******************************************************************************
 * Workload estimation Firmware CCB command structure for ROGUE
 ******************************************************************************
 */
struct rogue_fwif_workest_fwccb_cmd {
 /* Index for return data array */
 u16 return_data_index;
 /* The cycles the workload took on the hardware */
 u32 cycles_taken;
};

/*
 ******************************************************************************
 * Client CCB commands for ROGUE
 ******************************************************************************
 */

/*
 * Required memory alignment for 64-bit variables accessible by Meta
 * (The gcc meta aligns 64-bit variables to 64-bit; therefore, memory shared
 * between the host and meta that contains 64-bit variables has to maintain
 * this alignment)
 */
#define ROGUE_FWIF_FWALLOC_ALIGN sizeof(u64)

#define ROGUE_CCB_TYPE_TASK BIT(15)
#define ROGUE_CCB_FWALLOC_ALIGN(size)                \
 (((size) + (ROGUE_FWIF_FWALLOC_ALIGN - 1)) & \
  ~(ROGUE_FWIF_FWALLOC_ALIGN - 1))

#define ROGUE_FWIF_CCB_CMD_TYPE_GEOM \
 (201U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_TQ_3D \
 (202U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_FRAG \
 (203U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_FRAG_PR \
 (204U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_CDM \
 (205U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_TQ_TDM \
 (206U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_FBSC_INVALIDATE \
 (207U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_TQ_2D \
 (208U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_PRE_TIMESTAMP \
 (209U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_NULL \
 (210U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)
#define ROGUE_FWIF_CCB_CMD_TYPE_ABORT \
 (211U | ROGUE_CMD_MAGIC_DWORD_SHIFTED | ROGUE_CCB_TYPE_TASK)

/* Leave a gap between CCB specific commands and generic commands */
#define ROGUE_FWIF_CCB_CMD_TYPE_FENCE (212U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
#define ROGUE_FWIF_CCB_CMD_TYPE_UPDATE (213U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
#define ROGUE_FWIF_CCB_CMD_TYPE_RMW_UPDATE \
 (214U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
#define ROGUE_FWIF_CCB_CMD_TYPE_FENCE_PR (215U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
#define ROGUE_FWIF_CCB_CMD_TYPE_PRIORITY (216U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
/*
 * Pre and Post timestamp commands are supposed to sandwich the DM cmd. The
 * padding code with the CCB wrap upsets the FW if we don't have the task type
 * bit cleared for POST_TIMESTAMPs. That's why we have 2 different cmd types.
 */
#define ROGUE_FWIF_CCB_CMD_TYPE_POST_TIMESTAMP \
 (217U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
#define ROGUE_FWIF_CCB_CMD_TYPE_UNFENCED_UPDATE \
 (218U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)
#define ROGUE_FWIF_CCB_CMD_TYPE_UNFENCED_RMW_UPDATE \
 (219U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)

#define ROGUE_FWIF_CCB_CMD_TYPE_PADDING (221U | ROGUE_CMD_MAGIC_DWORD_SHIFTED)

struct rogue_fwif_workest_kick_data {
 /* Index for the KM Workload estimation return data array */
 u16 return_data_index __aligned(8);
 /* Predicted time taken to do the work in cycles */
 u32 cycles_prediction __aligned(8);
 /* Deadline for the workload */
 aligned_u64 deadline;
};

struct rogue_fwif_ccb_cmd_header {
 u32 cmd_type;
 u32 cmd_size;
 /*
 * external job reference - provided by client and used in debug for
 * tracking submitted work
 */
 u32 ext_job_ref;
 /*
 * internal job reference - generated by services and used in debug for
 * tracking submitted work
 */
 u32 int_job_ref;
 /* Workload Estimation - Workload Estimation Data */
 struct rogue_fwif_workest_kick_data work_est_kick_data __aligned(8);
};

/*
 ******************************************************************************
 * Client CCB commands which are only required by the kernel
 ******************************************************************************
 */
struct rogue_fwif_cmd_priority {
 s32 priority;
};

/*
 ******************************************************************************
 * Signature and Checksums Buffer
 ******************************************************************************
 */
struct rogue_fwif_sigbuf_ctl {
 /* Ptr to Signature Buffer memory */
 u32 buffer_fw_addr;
 /* Amount of space left for storing regs in the buffer */
 u32 left_size_in_regs;
} __aligned(8);

struct rogue_fwif_counter_dump_ctl {
 /* Ptr to counter dump buffer */
 u32 buffer_fw_addr;
 /* Amount of space for storing in the buffer */
 u32 size_in_dwords;
} __aligned(8);

struct rogue_fwif_firmware_gcov_ctl {
 /* Ptr to firmware gcov buffer */
 u32 buffer_fw_addr;
 /* Amount of space for storing in the buffer */
 u32 size;
} __aligned(8);

/*
 *****************************************************************************
 * ROGUE Compatibility checks
 *****************************************************************************
 */

/*
 * WARNING: Whenever the layout of ROGUE_FWIF_COMPCHECKS_BVNC changes, the
 * following define should be increased by 1 to indicate to the compatibility
 * logic that layout has changed.
 */
#define ROGUE_FWIF_COMPCHECKS_LAYOUT_VERSION 3

struct rogue_fwif_compchecks_bvnc {
 /* WARNING: This field must be defined as first one in this structure */
 u32 layout_version;
 aligned_u64 bvnc;
} __aligned(8);

struct rogue_fwif_init_options {
 u8 os_count_support;
 u8 padding[7];
} __aligned(8);

#define ROGUE_FWIF_COMPCHECKS_BVNC_DECLARE_AND_INIT(name) \
 struct rogue_fwif_compchecks_bvnc(name) = {       \
  ROGUE_FWIF_COMPCHECKS_LAYOUT_VERSION,     \
  0,                                        \
 }

static inline void rogue_fwif_compchecks_bvnc_init(struct rogue_fwif_compchecks_bvnc *compchecks)
{
 compchecks->layout_version = ROGUE_FWIF_COMPCHECKS_LAYOUT_VERSION;
 compchecks->bvnc = 0;
}

struct rogue_fwif_compchecks {
 /* hardware BVNC (from the ROGUE registers) */
 struct rogue_fwif_compchecks_bvnc hw_bvnc;
 /* firmware BVNC */
 struct rogue_fwif_compchecks_bvnc fw_bvnc;
 /* identifier of the FW processor version */
 u32 fw_processor_version;
 /* software DDK version */
 u32 ddk_version;
 /* software DDK build no. */
 u32 ddk_build;
 /* build options bit-field */
 u32 build_options;
 /* initialisation options bit-field */
 struct rogue_fwif_init_options init_options;
 /* Information is valid */
 bool updated __aligned(4);
 u32 padding;
} __aligned(8);

/*
 ******************************************************************************
 * Updated configuration post FW data init.
 ******************************************************************************
 */
struct rogue_fwif_runtime_cfg {
 /* APM latency in ms before signalling IDLE to the host */
 u32 active_pm_latency_ms;
 /* Compatibility and other flags */
 u32 runtime_cfg_flags;
 /*
 * If set, APM latency does not reset to system default each GPU power
 * transition
 */
 bool active_pm_latency_persistant __aligned(4);
 /* Core clock speed, currently only used to calculate timer ticks */
 u32 core_clock_speed;
 /* Last number of dusts change requested by the host */
 u32 default_dusts_num_init;
 /* Periodic Hardware Reset configuration values */
 u32 phr_mode;
 /* New number of milliseconds C/S is allowed to last */
 u32 hcs_deadline_ms;
 /* The watchdog period in microseconds */
 u32 wdg_period_us;
 /* Array of priorities per OS */
 u32 osid_priority[ROGUE_FW_MAX_NUM_OS];
 /* On-demand allocated HWPerf buffer address, to be passed to the FW */
 u32 hwperf_buf_fw_addr;

 bool padding __aligned(4);
};

/*
 *****************************************************************************
 * Control data for ROGUE
 *****************************************************************************
 */

#define ROGUE_FWIF_HWR_DEBUG_DUMP_ALL (99999U)

enum rogue_fwif_tpu_dm {
 ROGUE_FWIF_TPU_DM_PDM = 0,
 ROGUE_FWIF_TPU_DM_VDM = 1,
 ROGUE_FWIF_TPU_DM_CDM = 2,
 ROGUE_FWIF_TPU_DM_TDM = 3,
 ROGUE_FWIF_TPU_DM_LAST
};

enum rogue_fwif_gpio_val_mode {
 /* No GPIO validation */
 ROGUE_FWIF_GPIO_VAL_OFF = 0,
 /*
 * Simple test case that initiates by sending data via the GPIO and then
 * sends back any data received over the GPIO
 */
 ROGUE_FWIF_GPIO_VAL_GENERAL = 1,
 /*
 * More complex test case that writes and reads data across the entire
 * GPIO AP address range.
 */
 ROGUE_FWIF_GPIO_VAL_AP = 2,
 /* Validates the GPIO Testbench. */
 ROGUE_FWIF_GPIO_VAL_TESTBENCH = 5,
 /* Send and then receive each byte in the range 0-255. */
 ROGUE_FWIF_GPIO_VAL_LOOPBACK = 6,
 /* Send and then receive each power-of-2 byte in the range 0-255. */
 ROGUE_FWIF_GPIO_VAL_LOOPBACK_LITE = 7,
 ROGUE_FWIF_GPIO_VAL_LAST
};

enum fw_perf_conf {
 FW_PERF_CONF_NONE = 0,
 FW_PERF_CONF_ICACHE = 1,
 FW_PERF_CONF_DCACHE = 2,
 FW_PERF_CONF_JTLB_INSTR = 5,
 FW_PERF_CONF_INSTRUCTIONS = 6
};

enum fw_boot_stage {
 FW_BOOT_STAGE_TLB_INIT_FAILURE = -2,
 FW_BOOT_STAGE_NOT_AVAILABLE = -1,
 FW_BOOT_NOT_STARTED = 0,
 FW_BOOT_BLDR_STARTED = 1,
 FW_BOOT_CACHE_DONE,
 FW_BOOT_TLB_DONE,
 FW_BOOT_MAIN_STARTED,
 FW_BOOT_ALIGNCHECKS_DONE,
 FW_BOOT_INIT_DONE,
};

/*
 * Kernel CCB return slot responses. Usage of bit-fields instead of bare
 * integers allows FW to possibly pack-in several responses for each single kCCB
 * command.
 */
/* Command executed (return status from FW) */
#define ROGUE_FWIF_KCCB_RTN_SLOT_CMD_EXECUTED BIT(0)
/* A cleanup was requested but resource busy */
#define ROGUE_FWIF_KCCB_RTN_SLOT_CLEANUP_BUSY BIT(1)
/* Poll failed in FW for a HW operation to complete */
#define ROGUE_FWIF_KCCB_RTN_SLOT_POLL_FAILURE BIT(2)
/* Reset value of a kCCB return slot (set by host) */
#define ROGUE_FWIF_KCCB_RTN_SLOT_NO_RESPONSE 0x0U

struct rogue_fwif_connection_ctl {
 /* Fw-Os connection states */
 enum rogue_fwif_connection_fw_state connection_fw_state;
 enum rogue_fwif_connection_os_state connection_os_state;
 u32 alive_fw_token;
 u32 alive_os_token;
} __aligned(8);

struct rogue_fwif_osinit {
 /* Kernel CCB */
 u32 kernel_ccbctl_fw_addr;
 u32 kernel_ccb_fw_addr;
 u32 kernel_ccb_rtn_slots_fw_addr;

 /* Firmware CCB */
 u32 firmware_ccbctl_fw_addr;
 u32 firmware_ccb_fw_addr;

 /* Workload Estimation Firmware CCB */
 u32 work_est_firmware_ccbctl_fw_addr;
 u32 work_est_firmware_ccb_fw_addr;

 u32 rogue_fwif_hwr_info_buf_ctl_fw_addr;

 u32 hwr_debug_dump_limit;

 u32 fw_os_data_fw_addr;

 /* Compatibility checks to be populated by the Firmware */
 struct rogue_fwif_compchecks rogue_comp_checks;
} __aligned(8);

/* BVNC Features */
struct rogue_hwperf_bvnc_block {
 /* Counter block ID, see ROGUE_HWPERF_CNTBLK_ID */
 u16 block_id;

 /* Number of counters in this block type */
 u16 num_counters;

 /* Number of blocks of this type */
 u16 num_blocks;

 u16 reserved;
};

#define ROGUE_HWPERF_MAX_BVNC_LEN (24)

#define ROGUE_HWPERF_MAX_BVNC_BLOCK_LEN (16U)

/* BVNC Features */
struct rogue_hwperf_bvnc {
 /* BVNC string */
 char bvnc_string[ROGUE_HWPERF_MAX_BVNC_LEN];
 /* See ROGUE_HWPERF_FEATURE_FLAGS */
 u32 bvnc_km_feature_flags;
 /* Number of blocks described in aBvncBlocks */
 u16 num_bvnc_blocks;
 /* Number of GPU cores present */
 u16 bvnc_gpu_cores;
 /* Supported Performance Blocks for BVNC */
 struct rogue_hwperf_bvnc_block
  bvnc_blocks[ROGUE_HWPERF_MAX_BVNC_BLOCK_LEN];
};

PVR_FW_STRUCT_SIZE_ASSERT(struct rogue_hwperf_bvnc);

struct rogue_fwif_sysinit {
 /* Fault read address */
 aligned_u64 fault_phys_addr;

 /* PDS execution base */
 aligned_u64 pds_exec_base;
 /* UCS execution base */
 aligned_u64 usc_exec_base;
 /* FBCDC bindless texture state table base */
 aligned_u64 fbcdc_state_table_base;
 aligned_u64 fbcdc_large_state_table_base;
 /* Texture state base */
 aligned_u64 texture_heap_base;

 /* Event filter for Firmware events */
 u64 hw_perf_filter;

 aligned_u64 slc3_fence_dev_addr;

 u32 tpu_trilinear_frac_mask[ROGUE_FWIF_TPU_DM_LAST] __aligned(8);

 /* Signature and Checksum Buffers for DMs */
 struct rogue_fwif_sigbuf_ctl sigbuf_ctl[PVR_FWIF_DM_MAX];

 struct rogue_fwif_pdvfs_opp pdvfs_opp_info;

 struct rogue_fwif_dma_addr coremem_data_store;

 struct rogue_fwif_counter_dump_ctl counter_dump_ctl;

 u32 filter_flags;

 u32 runtime_cfg_fw_addr;

 u32 trace_buf_ctl_fw_addr;
 u32 fw_sys_data_fw_addr;

 u32 gpu_util_fw_cb_ctl_fw_addr;
 u32 reg_cfg_fw_addr;
 u32 hwperf_ctl_fw_addr;

 u32 align_checks;

 /* Core clock speed at FW boot time */
 u32 initial_core_clock_speed;

 /* APM latency in ms before signalling IDLE to the host */
 u32 active_pm_latency_ms;

 /* Flag to be set by the Firmware after successful start */
 bool firmware_started __aligned(4);

 /* Host/FW Trace synchronisation Partition Marker */
 u32 marker_val;

 /* Firmware initialization complete time */
 u32 firmware_started_timestamp;

 u32 jones_disable_mask;

 /* Firmware performance counter config */
 enum fw_perf_conf firmware_perf;

 /*
 * FW Pointer to memory containing core clock rate in Hz.
 * Firmware (PDVFS) updates the memory when running on non primary FW
 * thread to communicate to host driver.
 */
 u32 core_clock_rate_fw_addr;

 enum rogue_fwif_gpio_val_mode gpio_validation_mode;

 /* Used in HWPerf for decoding BVNC Features */
 struct rogue_hwperf_bvnc bvnc_km_feature_flags;

 /* Value to write into ROGUE_CR_TFBC_COMPRESSION_CONTROL */
 u32 tfbc_compression_control;
} __aligned(8);

/*
 *****************************************************************************
 * Timer correlation shared data and defines
 *****************************************************************************
 */

struct rogue_fwif_time_corr {
 aligned_u64 os_timestamp;
 aligned_u64 os_mono_timestamp;
 aligned_u64 cr_timestamp;

 /*
 * Utility variable used to convert CR timer deltas to OS timer deltas
 * (nS), where the deltas are relative to the timestamps above:
 * deltaOS = (deltaCR * K) >> decimal_shift, see full explanation below
 */
 aligned_u64 cr_delta_to_os_delta_kns;

 u32 core_clock_speed;
 u32 reserved;
} __aligned(8);

/*
 * The following macros are used to help converting FW timestamps to the Host
 * time domain. On the FW the ROGUE_CR_TIMER counter is used to keep track of
 * time; it increments by 1 every 256 GPU clock ticks, so the general
 * formula to perform the conversion is:
 *
 * [ GPU clock speed in Hz, if (scale == 10^9) then deltaOS is in nS,
 *   otherwise if (scale == 10^6) then deltaOS is in uS ]
 *
 *             deltaCR * 256                                   256 * scale
 *  deltaOS = --------------- * scale = deltaCR * K    [ K = --------------- ]
 *             GPUclockspeed                                  GPUclockspeed
 *
 * The actual K is multiplied by 2^20 (and deltaCR * K is divided by 2^20)
 * to get some better accuracy and to avoid returning 0 in the integer
 * division 256000000/GPUfreq if GPUfreq is greater than 256MHz.
 * This is the same as keeping K as a decimal number.
 *
 * The maximum deltaOS is slightly more than 5hrs for all GPU frequencies
 * (deltaCR * K is more or less a constant), and it's relative to the base
 * OS timestamp sampled as a part of the timer correlation data.
 * This base is refreshed on GPU power-on, DVFS transition and periodic
 * frequency calibration (executed every few seconds if the FW is doing
 * some work), so as long as the GPU is doing something and one of these
 * events is triggered then deltaCR * K will not overflow and deltaOS will be
 * correct.
 */

#define ROGUE_FWIF_CRDELTA_TO_OSDELTA_ACCURACY_SHIFT (20)

#define ROGUE_FWIF_GET_DELTA_OSTIME_NS(delta_cr, k) \
 (((delta_cr) * (k)) >> ROGUE_FWIF_CRDELTA_TO_OSDELTA_ACCURACY_SHIFT)

/*
 ******************************************************************************
 * GPU Utilisation
 ******************************************************************************
 */

/* See rogue_common.h for a list of GPU states */
#define ROGUE_FWIF_GPU_UTIL_TIME_MASK \
 (0xFFFFFFFFFFFFFFFFull & ~ROGUE_FWIF_GPU_UTIL_STATE_MASK)

#define ROGUE_FWIF_GPU_UTIL_GET_TIME(word) \
 ((word)(&ROGUE_FWIF_GPU_UTIL_TIME_MASK))
#define ROGUE_FWIF_GPU_UTIL_GET_STATE(word) \
 ((word)(&ROGUE_FWIF_GPU_UTIL_STATE_MASK))

/*
 * The OS timestamps computed by the FW are approximations of the real time,
 * which means they could be slightly behind or ahead the real timer on the
 * Host. In some cases we can perform subtractions between FW approximated
 * timestamps and real OS timestamps, so we need a form of protection against
 * negative results if for instance the FW one is a bit ahead of time.
 */
#define ROGUE_FWIF_GPU_UTIL_GET_PERIOD(newtime, oldtime) \
 (((newtime) > (oldtime)) ? ((newtime) - (oldtime)) : 0U)

#define ROGUE_FWIF_GPU_UTIL_MAKE_WORD(time, state) \
 (ROGUE_FWIF_GPU_UTIL_GET_TIME(time) |      \
  ROGUE_FWIF_GPU_UTIL_GET_STATE(state))

/*
 * The timer correlation array must be big enough to ensure old entries won't be
 * overwritten before all the HWPerf events linked to those entries are
 * processed by the MISR. The update frequency of this array depends on how fast
--> --------------------

--> maximum size reached

--> --------------------