Merge tag 'cxl-for-6.10' of git://git.kernel.org/pub/scm/linux/kernel/git/cxl/cxl

[linux.git] / drivers / gpu / drm / imagination / pvr_rogue_fwif.h

/* 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
 * the system can change state (basically how small the APM latency is) and
 * perform DVFS transitions.
 *
 * The minimum size is 2 (not 1) to avoid race conditions between the FW reading
 * an entry while the Host is updating it. With 2 entries in the worst case the
 * FW will read old data, which is still quite ok if the Host is updating the
 * timer correlation at that time.
 */
#define ROGUE_FWIF_TIME_CORR_ARRAY_SIZE 256U
#define ROGUE_FWIF_TIME_CORR_CURR_INDEX(seqcount) \
        ((seqcount) % ROGUE_FWIF_TIME_CORR_ARRAY_SIZE)

/* Make sure the timer correlation array size is a power of 2 */
static_assert((ROGUE_FWIF_TIME_CORR_ARRAY_SIZE &
               (ROGUE_FWIF_TIME_CORR_ARRAY_SIZE - 1U)) == 0U,
              "ROGUE_FWIF_TIME_CORR_ARRAY_SIZE must be a power of two");

struct rogue_fwif_gpu_util_fwcb {
        struct rogue_fwif_time_corr time_corr[ROGUE_FWIF_TIME_CORR_ARRAY_SIZE];
        u32 time_corr_seq_count;

        /* Compatibility and other flags */
        u32 gpu_util_flags;

        /* Last GPU state + OS time of the last state update */
        aligned_u64 last_word;

        /* Counters for the amount of time the GPU was active/idle/blocked */
        aligned_u64 stats_counters[PVR_FWIF_GPU_UTIL_STATE_NUM];
} __aligned(8);

struct rogue_fwif_rta_ctl {
        /* Render number */
        u32 render_target_index;
        /* index in RTA */
        u32 current_render_target;
        /* total active RTs */
        u32 active_render_targets;
        /* total active RTs from the first TA kick, for OOM */
        u32 cumul_active_render_targets;
        /* Array of valid RT indices */
        u32 valid_render_targets_fw_addr;
        /* Array of number of occurred partial renders per render target */
        u32 rta_num_partial_renders_fw_addr;
        /* Number of render targets in the array */
        u32 max_rts;
        /* Compatibility and other flags */
        u32 rta_ctl_flags;
} __aligned(8);

struct rogue_fwif_freelist {
        aligned_u64 freelist_dev_addr;
        aligned_u64 current_dev_addr;
        u32 current_stack_top;
        u32 max_pages;
        u32 grow_pages;
        /* HW pages */
        u32 current_pages;
        u32 allocated_page_count;
        u32 allocated_mmu_page_count;
        u32 freelist_id;

        bool grow_pending __aligned(4);
        /* Pages that should be used only when OOM is reached */
        u32 ready_pages;
        /* Compatibility and other flags */
        u32 freelist_flags;
        /* PM Global PB on which Freelist is loaded */
        u32 pm_global_pb;
        u32 padding;
} __aligned(8);

/*
 ******************************************************************************
 * HWRTData
 ******************************************************************************
 */

/* HWRTData flags */
/* Deprecated flags 1:0 */
#define HWRTDATA_HAS_LAST_GEOM BIT(2)
#define HWRTDATA_PARTIAL_RENDERED BIT(3)
#define HWRTDATA_DISABLE_TILE_REORDERING BIT(4)
#define HWRTDATA_NEED_BRN65101_BLIT BIT(5)
#define HWRTDATA_FIRST_BRN65101_STRIP BIT(6)
#define HWRTDATA_NEED_BRN67182_2ND_RENDER BIT(7)

enum rogue_fwif_rtdata_state {
        ROGUE_FWIF_RTDATA_STATE_NONE = 0,
        ROGUE_FWIF_RTDATA_STATE_KICK_GEOM,
        ROGUE_FWIF_RTDATA_STATE_KICK_GEOM_FIRST,
        ROGUE_FWIF_RTDATA_STATE_GEOM_FINISHED,
        ROGUE_FWIF_RTDATA_STATE_KICK_FRAG,
        ROGUE_FWIF_RTDATA_STATE_FRAG_FINISHED,
        ROGUE_FWIF_RTDATA_STATE_FRAG_CONTEXT_STORED,
        ROGUE_FWIF_RTDATA_STATE_GEOM_OUTOFMEM,
        ROGUE_FWIF_RTDATA_STATE_PARTIALRENDERFINISHED,
        /*
         * In case of HWR, we can't set the RTDATA state to NONE, as this will
         * cause any TA to become a first TA. To ensure all related TA's are
         * skipped, we use the HWR state
         */
        ROGUE_FWIF_RTDATA_STATE_HWR,
        ROGUE_FWIF_RTDATA_STATE_UNKNOWN = 0x7FFFFFFFU
};

struct rogue_fwif_hwrtdata_common {
        bool geom_caches_need_zeroing __aligned(4);

        u32 screen_pixel_max;
        aligned_u64 multi_sample_ctl;
        u64 flipped_multi_sample_ctl;
        u32 tpc_stride;
        u32 tpc_size;
        u32 te_screen;
        u32 mtile_stride;
        u32 teaa;
        u32 te_mtile1;
        u32 te_mtile2;
        u32 isp_merge_lower_x;
        u32 isp_merge_lower_y;
        u32 isp_merge_upper_x;
        u32 isp_merge_upper_y;
        u32 isp_merge_scale_x;
        u32 isp_merge_scale_y;
        u32 rgn_header_size;
        u32 isp_mtile_size;
        u32 padding;
} __aligned(8);

struct rogue_fwif_hwrtdata {
        /* MList Data Store */
        aligned_u64 pm_mlist_dev_addr;

        aligned_u64 vce_cat_base[4];
        aligned_u64 vce_last_cat_base[4];
        aligned_u64 te_cat_base[4];
        aligned_u64 te_last_cat_base[4];
        aligned_u64 alist_cat_base;
        aligned_u64 alist_last_cat_base;

        aligned_u64 pm_alist_stack_pointer;
        u32 pm_mlist_stack_pointer;

        u32 hwrt_data_common_fw_addr;

        u32 hwrt_data_flags;
        enum rogue_fwif_rtdata_state state;

        u32 freelists_fw_addr[MAX_FREELISTS_SIZE] __aligned(8);
        u32 freelist_hwr_snapshot[MAX_FREELISTS_SIZE];

        aligned_u64 vheap_table_dev_addr;

        struct rogue_fwif_rta_ctl rta_ctl;

        aligned_u64 tail_ptrs_dev_addr;
        aligned_u64 macrotile_array_dev_addr;
        aligned_u64 rgn_header_dev_addr;
        aligned_u64 rtc_dev_addr;

        u32 owner_geom_not_used_by_host __aligned(8);

        bool geom_caches_need_zeroing __aligned(4);

        struct rogue_fwif_cleanup_ctl cleanup_state __aligned(64);
} __aligned(8);

/*
 ******************************************************************************
 * Sync checkpoints
 ******************************************************************************
 */

#define PVR_SYNC_CHECKPOINT_UNDEF 0x000
#define PVR_SYNC_CHECKPOINT_ACTIVE 0xac1     /* Checkpoint has not signaled. */
#define PVR_SYNC_CHECKPOINT_SIGNALED 0x519   /* Checkpoint has signaled. */
#define PVR_SYNC_CHECKPOINT_ERRORED 0xeff    /* Checkpoint has been errored. */

#include "pvr_rogue_fwif_check.h"

#endif /* PVR_ROGUE_FWIF_H */