// SPDX-License-Identifier: GPL-2.0

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "linux.h"
#include "ipa_version.h"
#include "ipa_reg.h"
#include "ipa_reg_new.h"

struct ipa;

static const struct ipa_regs *ipa_regs[] = {
	[IPA_VERSION_3_0]	= &ipa_regs_v3_0,
	[IPA_VERSION_3_1]	= &ipa_regs_v3_1,
	[IPA_VERSION_3_5]	= &ipa_regs_v3_5,
	[IPA_VERSION_3_5_1]	= &ipa_regs_v3_5_1,
	[IPA_VERSION_4_0]	= &ipa_regs_v4_0,
	[IPA_VERSION_4_1]	= &ipa_regs_v4_1,
	[IPA_VERSION_4_2]	= &ipa_regs_v4_2,
	[IPA_VERSION_4_5]	= &ipa_regs_v4_5,
	[IPA_VERSION_4_7]	= &ipa_regs_v4_7,
	[IPA_VERSION_4_9]	= &ipa_regs_v4_9,
	[IPA_VERSION_4_11]	= &ipa_regs_v4_11,
};

static const char *version_string(enum ipa_version version)
{
	switch (version) {
	case IPA_VERSION_3_0:
		return "3.0";
	case IPA_VERSION_3_1:
		return "3.1";
	case IPA_VERSION_3_5:
		return "3.5";
	case IPA_VERSION_3_5_1:
		return "3.5.1";
	case IPA_VERSION_4_0:
		return "4.0";
	case IPA_VERSION_4_1:
		return "4.1";
	case IPA_VERSION_4_2:
		return "4.2";
	case IPA_VERSION_4_5:
		return "4.5";
	case IPA_VERSION_4_7:
		return "4.7";
	case IPA_VERSION_4_9:
		return "4.9";
	case IPA_VERSION_4_11:
		return "4.11";
	default:
		return "0.0";   /* Won't happen (checked at probe time) */
	}
}

static void ipa_reg_dump(const struct ipa_reg *reg)
{
	u32 i = 0;

	printf("ipa_reg %s:\n", reg->name);
	printf("         offset: 0x%04x\n", reg->offset);
	printf("    field_count: %u\n", reg->field_count);
	if (reg->field_count) {
		do
			printf("  %2u: 0x%08x\n", i, reg->fmask[i]);
		while (++i < reg->field_count);
	}
}

#define ipa_reg_test_fmask(eg, field, mask) \
	__ipa_reg_test_fmask((reg), (field), #field, (mask))

static void __ipa_reg_test_fmask(const struct ipa_reg *reg, u32 field,
				      const char *name, u32 mask)
{
	u32 fmask;

	if (field >= reg->field_count) {
		if (!mask)
			return;
		printf("%s field %s is not defined (want 0x%08x)\n",
			reg->name, name, mask);
		exit(1);
	}

	fmask = reg->fmask[field];
	if (mask != fmask) {
		if (mask && fmask)
			printf("%s field %s is wrong (want 0x%08x got 0x%08x)\n",
				reg->name, name, mask, fmask);
		else if (mask)
			printf("%s field %s is not defined (want 0x%08x)\n",
				reg->name, name, mask);
		else
			printf("%s field %s should not be defined (got 0x%08x)\n",
				reg->name, name, fmask);
		ipa_reg_dump(reg);
		exit(1);
	}
}

static void ipa_reg_test_comp_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* COMP_CFG is defined for all versions */
	if (IPA_REG_COMP_CFG >= regs->reg_count) {
		printf("version %s COMP_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_COMP_CFG];
	if (!reg) {
		printf("version %s COMP_CFG not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s COMP_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "COMP_CFG")) {
		printf("version %s COMP_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_COMP_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_COMP_CFG_OFFSET);
		exit(1);
	}

	mask = version < IPA_VERSION_4_0 ? ENABLE_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_ENABLE, mask);

	mask = version >= IPA_VERSION_4_7
			? RAM_ARB_PRI_CLIENT_SAMP_FIX_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, RAM_ARB_PRI_CLIENT_SAMP_FIX_DIS, mask);

	mask = GSI_SNOC_BYPASS_DIS_FMASK;
	ipa_reg_test_fmask(reg, COMP_CFG_GSI_SNOC_BYPASS_DIS, mask);

	mask = GEN_QMB_0_SNOC_BYPASS_DIS_FMASK;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_0_SNOC_BYPASS_DIS, mask);

	mask = GEN_QMB_1_SNOC_BYPASS_DIS_FMASK;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_1_SNOC_BYPASS_DIS, mask);

	mask = version < IPA_VERSION_4_5
			? IPA_DCMP_FAST_CLK_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_IPA_DCMP_FAST_CLK_EN, mask);

	mask = version >= IPA_VERSION_4_0
			? IPA_QMB_SELECT_CONS_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_IPA_QMB_SELECT_CONS_EN, mask);

	mask = version >= IPA_VERSION_4_0
			? IPA_QMB_SELECT_PROD_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_IPA_QMB_SELECT_PROD_EN, mask);

	mask = version >= IPA_VERSION_4_0
			? GSI_MULTI_INORDER_RD_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GSI_MULTI_INORDER_RD_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GSI_MULTI_INORDER_WR_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GSI_MULTI_INORDER_WR_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_0_MULTI_INORDER_RD_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_0_MULTI_INORDER_RD_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_1_MULTI_INORDER_RD_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_1_MULTI_INORDER_RD_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_0_MULTI_INORDER_WR_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_0_MULTI_INORDER_WR_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_1_MULTI_INORDER_WR_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_1_MULTI_INORDER_WR_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_0_SNOC_CNOC_LOOP_PROT_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_0_SNOC_CNOC_LOOP_PROT_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? GSI_SNOC_CNOC_LOOP_PROT_DISABLE_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GSI_SNOC_CNOC_LOOP_PROT_DISABLE, mask);

	mask = version >= IPA_VERSION_4_0
			? GSI_MULTI_AXI_MASTERS_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GSI_MULTI_AXI_MASTERS_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? IPA_QMB_SELECT_GLOBAL_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_IPA_QMB_SELECT_GLOBAL_EN, mask);

	mask = version >= IPA_VERSION_4_9
			? QMB_RAM_RD_CACHE_DISABLE_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_QMB_RAM_RD_CACHE_DISABLE, mask);

	mask = version >= IPA_VERSION_4_9
			? GENQMB_AOOOWR_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GENQMB_AOOOWR, mask);

	mask = version >= IPA_VERSION_4_9
			? IF_OUT_OF_BUF_STOP_RESET_MASK_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_IF_OUT_OF_BUF_STOP_RESET_MASK_EN, mask);

	mask = version >= IPA_VERSION_4_9
			? GEN_QMB_1_DYNAMIC_ASIZE_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_1_DYNAMIC_ASIZE, mask);

	mask = version >= IPA_VERSION_4_9
			? GEN_QMB_0_DYNAMIC_ASIZE_FMASK : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_GEN_QMB_0_DYNAMIC_ASIZE, mask);

	/* We have to custom-do this to avoid field overflow */
	mask = version >= IPA_VERSION_4_0
		? version < IPA_VERSION_4_9
		   ? arbitration_lock_disable_encoded(version, 0xf)
		   : version == IPA_VERSION_4_9
		      ? arbitration_lock_disable_encoded(version, 0x7)
		      : arbitration_lock_disable_encoded(version, 0x3)
		: 0;
	ipa_reg_test_fmask(reg, COMP_CFG_ATOMIC_FETCHER_ARB_LOCK_DIS, mask);

	mask = version >= IPA_VERSION_4_5
			? full_flush_rsc_closure_en_encoded(version, true) : 0;
	ipa_reg_test_fmask(reg, COMP_CFG_FULL_FLUSH_WAIT_RS_CLOSURE_EN, mask);
}

static void ipa_reg_test_clkon_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* CLKON_CFG is defined for all versions */
	if (IPA_REG_CLKON_CFG >= regs->reg_count) {
		printf("version %s CLKON_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_CLKON_CFG];
	if (!reg) {
		printf("version %s CLKON_CFG not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s CLKON_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "CLKON_CFG")) {
		printf("version %s CLKON_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_CLKON_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old %04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_COMP_CFG_OFFSET);
		exit(1);
	}

	mask = RX_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_RX, mask);

	mask = PROC_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_PROC, mask);

	mask = TX_WRAPPER_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_TX_WRAPPER, mask);

	mask = MISC_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_MISC, mask);

	mask = RAM_ARB_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_RAM_ARB, mask);

	mask = FTCH_HPS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_FTCH_HPS, mask);

	mask = FTCH_DPS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_FTCH_DPS, mask);

	mask = HPS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_HPS, mask);

	mask = DPS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_DPS, mask);

	mask = RX_HPS_CMDQS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_RX_HPS_CMDQS, mask);

	mask = HPS_DPS_CMDQS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_HPS_DPS_CMDQS, mask);

	mask = DPS_TX_CMDQS_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_DPS_TX_CMDQS, mask);

	mask = RSRC_MNGR_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_RSRC_MNGR, mask);

	mask = CTX_HANDLER_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_CTX_HANDLER, mask);

	mask = ACK_MNGR_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_ACK_MNGR, mask);

	mask = D_DCPH_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_D_DCPH, mask);

	mask = H_DCPH_FMASK;
	ipa_reg_test_fmask(reg, CLKON_CFG_H_DCPH, mask);

	mask = version < IPA_VERSION_4_5
			? DCMP_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_DCMP, mask);

	mask = version >= IPA_VERSION_3_5
			? NTF_TX_CMDQS_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_NTF_TX_CMDQS, mask);

	mask = version >= IPA_VERSION_3_5
			? TX_0_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_TX_0, mask);

	mask = version >= IPA_VERSION_3_5
			? TX_1_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_TX_1, mask);

	mask = version >= IPA_VERSION_3_5_1
			? FNR_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_FNR, mask);

	mask = version >= IPA_VERSION_4_0
			? QSB2AXI_CMDQ_L_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_QSB2AXI_CMDQ_L, mask);

	mask = version >= IPA_VERSION_4_0
			? AGGR_WRAPPER_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_AGGR_WRAPPER, mask);

	mask = version >= IPA_VERSION_4_0
			? RAM_SLAVEWAY_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_RAM_SLAVEWAY, mask);

	mask = version >= IPA_VERSION_4_0
			? QMB_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_QMB, mask);

	mask = version >= IPA_VERSION_4_0
			? WEIGHT_ARB_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_WEIGHT_ARB, mask);

	mask = version >= IPA_VERSION_4_0
			? GSI_IF_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_GSI_IF, mask);

	mask = version >= IPA_VERSION_4_0
			? GLOBAL_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_GLOBAL, mask);

	mask = version >= IPA_VERSION_4_0
			? GLOBAL_2X_CLK_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_GLOBAL_2X_CLK, mask);

	mask = version >= IPA_VERSION_4_5
			? DPL_FIFO_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_DPL_FIFO, mask);

	mask = version >= IPA_VERSION_4_7
			? DRBIP_FMASK : 0;
	ipa_reg_test_fmask(reg, CLKON_CFG_DRBIP, mask);
}

static void ipa_reg_test_route(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* ROUTE is defined for all versions */
	if (IPA_REG_ROUTE >= regs->reg_count) {
		printf("version %s ROUTE > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_ROUTE];
	if (!reg) {
		printf("version %s ROUTE not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s ROUTE has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "ROUTE")) {
		printf("version %s ROUTE has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_ROUTE_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_ROUTE_OFFSET);
		exit(1);
	}

	/* All ROUTE fields are defined for all versions */
	mask = ROUTE_DIS_FMASK;
	ipa_reg_test_fmask(reg, ROUTE_DIS, mask);

	mask = ROUTE_DEF_PIPE_FMASK;
	ipa_reg_test_fmask(reg, ROUTE_DEF_PIPE, mask);

	mask = ROUTE_DEF_HDR_TABLE_FMASK;
	ipa_reg_test_fmask(reg, ROUTE_DEF_HDR_TABLE, mask);

	mask = ROUTE_DEF_HDR_OFST_FMASK;
	ipa_reg_test_fmask(reg, ROUTE_DEF_HDR_OFST, mask);

	mask = ROUTE_FRAG_DEF_PIPE_FMASK;
	ipa_reg_test_fmask(reg, ROUTE_FRAG_DEF_PIPE, mask);

	mask = ROUTE_DEF_RETAIN_HDR_FMASK;
	ipa_reg_test_fmask(reg, ROUTE_DEF_RETAIN_HDR, mask);
}

static void ipa_reg_test_shared_mem_size(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* SHARED_MEM_SIZE is defined for all versions */
	if (IPA_REG_SHARED_MEM_SIZE >= regs->reg_count) {
		printf("version %s SHARED_MEM_SIZE > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_SHARED_MEM_SIZE];
	if (!reg) {
		printf("version %s SHARED_MEM_SIZE not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s SHARED_MEM_SIZE has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "SHARED_MEM_SIZE")) {
		printf("version %s SHARED_MEM_SIZE has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_SHARED_MEM_SIZE_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_SHARED_MEM_SIZE_OFFSET);
		exit(1);
	}

	/* All SHARED_MEM_SIZE fields are defined for all versions */
	mask = SHARED_MEM_SIZE_FMASK;
	ipa_reg_test_fmask(reg, SHARED_MEM_SIZE, mask);

	mask = SHARED_MEM_BADDR_FMASK;
	ipa_reg_test_fmask(reg, SHARED_MEM_BADDR, mask);
}

static void ipa_reg_test_qsb_max_writes(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* QSB_MAX_WRITES is defined for all versions */
	if (IPA_REG_QSB_MAX_WRITES >= regs->reg_count) {
		printf("version %s QSB_MAX_WRITES > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_QSB_MAX_WRITES];
	if (!reg) {
		printf("version %s QSB_MAX_WRITES not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s QSB_MAX_WRITES has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "QSB_MAX_WRITES")) {
		printf("version %s QSB_MAX_WRITES has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_QSB_MAX_WRITES_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_QSB_MAX_WRITES_OFFSET);
		exit(1);
	}

	/* All QSB_MAX_WRITES fields are defined for all versions */
	mask = GEN_QMB_0_MAX_WRITES_FMASK;
	ipa_reg_test_fmask(reg, GEN_QMB_0_MAX_WRITES, mask);

	mask = GEN_QMB_1_MAX_WRITES_FMASK;
	ipa_reg_test_fmask(reg, GEN_QMB_1_MAX_WRITES, mask);
}

static void ipa_reg_test_qsb_max_reads(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* QSB_MAX_READS is defined for all versions */
	if (IPA_REG_QSB_MAX_READS >= regs->reg_count) {
		printf("version %s QSB_MAX_READS > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_QSB_MAX_READS];
	if (!reg) {
		printf("version %s QSB_MAX_READS not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s QSB_MAX_READS has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "QSB_MAX_READS")) {
		printf("version %s QSB_MAX_READS has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_QSB_MAX_READS_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_QSB_MAX_READS_OFFSET);
		exit(1);
	}

	mask = GEN_QMB_0_MAX_READS_FMASK;
	ipa_reg_test_fmask(reg, GEN_QMB_0_MAX_READS, mask);

	mask = GEN_QMB_1_MAX_READS_FMASK;
	ipa_reg_test_fmask(reg, GEN_QMB_1_MAX_READS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_0_MAX_READS_BEATS_FMASK : 0;
	ipa_reg_test_fmask(reg, GEN_QMB_0_MAX_READS_BEATS, mask);

	mask = version >= IPA_VERSION_4_0
			? GEN_QMB_1_MAX_READS_BEATS_FMASK : 0;
	ipa_reg_test_fmask(reg, GEN_QMB_1_MAX_READS_BEATS, mask);
}

static void ipa_reg_test_filt_rout_hash_en(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* FILT_ROUT_HASH_EN is defined for all versions */
	if (IPA_REG_FILT_ROUT_HASH_EN >= regs->reg_count) {
		printf("version %s FILT_ROUT_HASH_EN > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_FILT_ROUT_HASH_EN];
	if (!reg) {
		printf("version %s FILT_ROUT_HASH_EN not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s FILT_ROUT_HASH_EN has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "FILT_ROUT_HASH_EN")) {
		printf("version %s FILT_ROUT_HASH_EN has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != ipa_reg_filt_rout_hash_en_offset(version)) {
		printf("version %s FILT_ROUT_HASH_EN offset 0x%04x, old 0x%04x\n",
			vers, reg->offset, ipa_reg_filt_rout_hash_en_offset(version));
		exit(1);
	}

	/* All FILT_ROUT_HASH_EN fields are defined for all versions */
	mask = IPV6_ROUTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV6_ROUTER_HASH, mask);

	mask = IPV6_FILTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV6_FILTER_HASH, mask);

	mask = IPV4_ROUTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV4_ROUTER_HASH, mask);

	mask = IPV4_FILTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV4_FILTER_HASH, mask);
}

static void ipa_reg_test_filt_rout_hash_flush(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	/* FILT_ROUT_HASH_FLUSH is defined for all versions */
	if (IPA_REG_FILT_ROUT_HASH_FLUSH >= regs->reg_count) {
		printf("version %s FILT_ROUT_HASH_FLUSH > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_FILT_ROUT_HASH_FLUSH];
	if (!reg) {
		printf("version %s FILT_ROUT_HASH_FLUSH not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s FILT_ROUT_HASH_FLUSH has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "FILT_ROUT_HASH_FLUSH")) {
		printf("version %s FILT_ROUT_HASH_FLUSH has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != ipa_reg_filt_rout_hash_flush_offset(version)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			ipa_reg_filt_rout_hash_flush_offset(version));
		exit(1);
	}

	/* All FILT_ROUT_HASH_FLUSH fields are defined for all versions */
	mask = IPV6_ROUTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV6_ROUTER_HASH, mask);

	mask = IPV6_FILTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV6_FILTER_HASH, mask);

	mask = IPV4_ROUTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV4_ROUTER_HASH, mask);

	mask = IPV4_FILTER_HASH_FMASK;
	ipa_reg_test_fmask(reg, IPV4_FILTER_HASH, mask);
}

static void ipa_reg_test_state_aggr_active(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;

	/* STATE_AGGR_ACTIVE is defined for all versions */
	if (IPA_REG_STATE_AGGR_ACTIVE >= regs->reg_count) {
		printf("version %s STATE_AGGR_ACTIVE > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_STATE_AGGR_ACTIVE];
	if (!reg) {
		printf("version %s STATE_AGGR_ACTIVE not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s STATE_AGGR_ACTIVE has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "STATE_AGGR_ACTIVE")) {
		printf("version %s STATE_AGGR_ACTIVE has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != ipa_reg_state_aggr_active_offset(version)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			ipa_reg_state_aggr_active_offset(version));
		exit(1);
	}

	if (reg->field_count) {
		printf("version %s STATE_AGGR_ACTIVE has %u fields should have none\n",
			vers, reg->field_count);
		exit(1);
	}
}

static void ipa_reg_test_bcr(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_BCR >= regs->reg_count) {
		if (version >= IPA_VERSION_4_5)
			return;

		printf("version %s BCR > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_BCR];
	if (!reg) {
		if (version >= IPA_VERSION_4_5)
			return;

		printf("version %s BCR not defined\n",
			vers);
		exit(1);
	} else if (version >= IPA_VERSION_4_5) {
		printf("version %s BCR should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s BCR has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "BCR")) {
		printf("version %s BCR has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_BCR_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_BCR_OFFSET);
		exit(1);
	}

	mask = version < IPA_VERSION_4_2
			? BCR_CMDQ_L_LACK_ONE_ENTRY_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_CMDQ_L_LACK_ONE_ENTRY, mask);

	mask = version < IPA_VERSION_4_2
			? BCR_TX_NOT_USING_BRESP_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_TX_NOT_USING_BRESP, mask);

	mask = version < IPA_VERSION_4_0
			? BCR_TX_SUSPEND_IRQ_ASSERT_ONCE_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_TX_SUSPEND_IRQ_ASSERT_ONCE, mask);

	mask = version < IPA_VERSION_4_2
			? BCR_SUSPEND_L2_IRQ_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_SUSPEND_L2_IRQ, mask);

	mask = version < IPA_VERSION_4_2
			? BCR_HOLB_DROP_L2_IRQ_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_HOLB_DROP_L2_IRQ, mask);

	mask = version >= IPA_VERSION_3_5
			? BCR_DUAL_TX_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_DUAL_TX, mask);

	mask = version >= IPA_VERSION_3_5
			? BCR_ENABLE_FILTER_DATA_CACHE_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_ENABLE_FILTER_DATA_CACHE, mask);

	mask = version >= IPA_VERSION_3_5
			? BCR_NOTIF_PRIORITY_OVER_ZLT_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_NOTIF_PRIORITY_OVER_ZLT, mask);

	mask = version >= IPA_VERSION_3_5
			? BCR_FILTER_PREFETCH_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_FILTER_PREFETCH_EN, mask);

	mask = version >= IPA_VERSION_3_5
			? BCR_ROUTER_PREFETCH_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, BCR_ROUTER_PREFETCH_EN, mask);
}

static void ipa_reg_test_local_pkt_proc_cntxt(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_LOCAL_PKT_PROC_CNTXT >= regs->reg_count) {
		printf("version %s LOCAL_PKT_PROC_CNTXT > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_LOCAL_PKT_PROC_CNTXT];
	if (!reg) {
		printf("version %s LOCAL_PKT_PROC_CNTXT not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s LOCAL_PKT_PROC_CNTXT has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "LOCAL_PKT_PROC_CNTXT")) {
		printf("version %s LOCAL_PKT_PROC_CNTXT has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_LOCAL_PKT_PROC_CNTXT_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_LOCAL_PKT_PROC_CNTXT_OFFSET);
		exit(1);
	}

	/* We have to custom-do this to avoid field overflow */
	mask = version < IPA_VERSION_4_5
			? proc_cntxt_base_addr_encoded(version, 0x1ffff)
			: proc_cntxt_base_addr_encoded(version, 0x3ffff);
	ipa_reg_test_fmask(reg, LOCAL_PKT_CNTXT_BASE_ADDR, mask);
}

static void ipa_reg_test_aggr_force_close(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;

	/* AGGR_FORCE_CLOSE is defined for all versions */
	if (IPA_REG_AGGR_FORCE_CLOSE >= regs->reg_count) {
		printf("version %s AGGR_FORCE_CLOSE > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_AGGR_FORCE_CLOSE];
	if (!reg) {
		printf("version %s AGGR_FORCE_CLOSE not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s AGGR_FORCE_CLOSE has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "AGGR_FORCE_CLOSE")) {
		printf("version %s AGGR_FORCE_CLOSE has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_AGGR_FORCE_CLOSE_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_AGGR_FORCE_CLOSE_OFFSET);
		exit(1);
	}

	if (reg->field_count) {
		printf("version %s AGGR_FORCE_CLOSE has %u fields should have none\n",
			vers, reg->field_count);
		exit(1);
	}
}

static void ipa_reg_test_counter_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_COUNTER_CFG >= regs->reg_count) {
		if (version >= IPA_VERSION_4_5)
			return;

		printf("version %s COUNTER_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_COUNTER_CFG];
	if (!reg) {
		if (version >= IPA_VERSION_4_5)
			return;

		printf("version %s COUNTER_CFG not defined\n",
			vers);
		exit(1);
	} else if (version >= IPA_VERSION_4_5) {
		printf("version %s COUNTER_CFG should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s COUNTER_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "COUNTER_CFG")) {
		printf("version %s COUNTER_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_COUNTER_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_COUNTER_CFG_OFFSET);
		exit(1);
	}

	mask = version < IPA_VERSION_3_5
			? EOT_COAL_GRANULARITY : 0;
	ipa_reg_test_fmask(reg, EOT_COAL_GRANULARITY_FMASK, mask);

	mask = AGGR_GRANULARITY_FMASK;
	ipa_reg_test_fmask(reg, AGGR_GRANULARITY, mask);
}

static void ipa_reg_test_tx_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_TX_CFG >= regs->reg_count) {
		if (version < IPA_VERSION_3_5)
			return;

		printf("version %s TX_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_TX_CFG];
	if (!reg) {
		if (version < IPA_VERSION_3_5)
			return;

		printf("version %s TX_CFG not defined\n",
			vers);
		exit(1);
	} else if (version < IPA_VERSION_3_5) {
		printf("version %s TX_CFG should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s TX_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "TX_CFG")) {
		printf("version %s COUNTER_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_TX_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_TX_CFG_OFFSET);
		exit(1);
	}

	mask = version < IPA_VERSION_4_0
			? TX0_PREFETCH_DISABLE_FMASK : 0;
	ipa_reg_test_fmask(reg, TX0_PREFETCH_DISABLE, mask);

	mask = version < IPA_VERSION_4_0
			? TX1_PREFETCH_DISABLE_FMASK : 0;
	ipa_reg_test_fmask(reg, TX1_PREFETCH_DISABLE, mask);

	mask = version < IPA_VERSION_4_0
			? PREFETCH_ALMOST_EMPTY_SIZE_FMASK : 0;
	ipa_reg_test_fmask(reg, PREFETCH_ALMOST_EMPTY_SIZE, mask);

	mask = version >= IPA_VERSION_4_0
			? PREFETCH_ALMOST_EMPTY_SIZE_TX0_FMASK : 0;
	ipa_reg_test_fmask(reg, PREFETCH_ALMOST_EMPTY_SIZE_TX0, mask);

	mask = version >= IPA_VERSION_4_0
			? DMAW_SCND_OUTSD_PRED_THRESHOLD_FMASK : 0;
	ipa_reg_test_fmask(reg, DMAW_SCND_OUTSD_PRED_THRESHOLD, mask);

	mask = version >= IPA_VERSION_4_0
			? DMAW_SCND_OUTSD_PRED_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, DMAW_SCND_OUTSD_PRED_EN, mask);

	mask = version >= IPA_VERSION_4_0
			? DMAW_MAX_BEATS_256_DIS_FMASK : 0;
	ipa_reg_test_fmask(reg, DMAW_MAX_BEATS_256_DIS, mask);

	mask = version >= IPA_VERSION_4_0
			? PA_MASK_EN_FMASK : 0;
	ipa_reg_test_fmask(reg, PA_MASK_EN, mask);

	mask = version >= IPA_VERSION_4_5
			? DUAL_TX_ENABLE_FMASK : 0;
	ipa_reg_test_fmask(reg, DUAL_TX_ENABLE, mask);

	mask = version >= IPA_VERSION_4_2 && version != IPA_VERSION_4_5
			? SSPND_PA_NO_START_STATE_FMASK : 0;
	ipa_reg_test_fmask(reg, SSPND_PA_NO_START_STATE, mask);

	mask = version == IPA_VERSION_4_2
			? SSPND_PA_NO_BQ_STATE_FMASK : 0;
	ipa_reg_test_fmask(reg, SSPND_PA_NO_BQ_STATE, mask);
}

static void ipa_reg_test_flavor_0(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_FLAVOR_0 >= regs->reg_count) {
		if (version < IPA_VERSION_3_5)
			return;

		printf("version %s FLAVOR_0 > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_FLAVOR_0];
	if (!reg) {
		if (version < IPA_VERSION_3_5)
			return;

		printf("version %s FLAVOR_0 not defined\n",
			vers);
		exit(1);
	} else if (version < IPA_VERSION_3_5) {
		printf("version %s FLAVOR_0 should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s FLAVOR_0 has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "FLAVOR_0")) {
		printf("version %s FLAVOR_0 has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_FLAVOR_0_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_FLAVOR_0_OFFSET);
		exit(1);
	}

	mask = IPA_MAX_PIPES_FMASK;
	ipa_reg_test_fmask(reg, IPA_MAX_PIPES, mask);

	mask = IPA_MAX_CONS_PIPES_FMASK;
	ipa_reg_test_fmask(reg, IPA_MAX_CONS_PIPES, mask);

	mask = IPA_MAX_PROD_PIPES_FMASK;
	ipa_reg_test_fmask(reg, IPA_MAX_PROD_PIPES, mask);

	mask = IPA_PROD_LOWEST_FMASK;
	ipa_reg_test_fmask(reg, IPA_PROD_LOWEST, mask);
}

static void ipa_reg_test_idle_indication_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_IDLE_INDICATION_CFG >= regs->reg_count) {
		if (version < IPA_VERSION_3_5)
			return;

		printf("version %s IDLE_INDICATION_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_IDLE_INDICATION_CFG];
	if (!reg) {
		if (version < IPA_VERSION_3_5)
			return;

		printf("version %s IDLE_INDICATION_CFG not defined\n",
			vers);
		exit(1);
	} else if (version < IPA_VERSION_3_5) {
		printf("version %s IDLE_INDICATION_CFG should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IDLE_INDICATION_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "IDLE_INDICATION_CFG")) {
		printf("version %s IDLE_INDICATION_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != ipa_reg_idle_indication_cfg_offset(version)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			ipa_reg_idle_indication_cfg_offset(version));
		exit(1);
	}

	mask = ENTER_IDLE_DEBOUNCE_THRESH_FMASK;
	ipa_reg_test_fmask(reg, ENTER_IDLE_DEBOUNCE_THRESH, mask);

	mask = CONST_NON_IDLE_ENABLE_FMASK;
	ipa_reg_test_fmask(reg, CONST_NON_IDLE_ENABLE, mask);
}

static void ipa_reg_test_qtime_timestamp_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_QTIME_TIMESTAMP_CFG >= regs->reg_count) {
		if (version < IPA_VERSION_4_5)
			return;

		printf("version %s QTIME_TIMESTAMP_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_QTIME_TIMESTAMP_CFG];
	if (!reg) {
		if (version < IPA_VERSION_4_5)
			return;

		printf("version %s QTIME_TIMESTAMP_CFG not defined\n",
			vers);
		exit(1);
	} else if (version < IPA_VERSION_4_5) {
		printf("version %s QTIME_TIMESTAMP_CFG should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s QTIME_TIMESTAMP_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "QTIME_TIMESTAMP_CFG")) {
		printf("version %s COUNTER_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_QTIME_TIMESTAMP_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_QTIME_TIMESTAMP_CFG_OFFSET);
		exit(1);
	}

	mask = DPL_TIMESTAMP_LSB_FMASK;
	ipa_reg_test_fmask(reg, DPL_TIMESTAMP_LSB, mask);

	mask = DPL_TIMESTAMP_SEL_FMASK;
	ipa_reg_test_fmask(reg, DPL_TIMESTAMP_SEL, mask);

	mask = TAG_TIMESTAMP_LSB_FMASK;
	ipa_reg_test_fmask(reg, TAG_TIMESTAMP_LSB, mask);

	mask = NAT_TIMESTAMP_LSB_FMASK;
	ipa_reg_test_fmask(reg, NAT_TIMESTAMP_LSB, mask);
}

static void ipa_reg_test_timers_xo_clk_div_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_TIMERS_XO_CLK_DIV_CFG >= regs->reg_count) {
		if (version < IPA_VERSION_4_5)
			return;

		printf("version %s TIMERS_XO_CLK_DIV_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_TIMERS_XO_CLK_DIV_CFG];
	if (!reg) {
		if (version < IPA_VERSION_4_5)
			return;

		printf("version %s TIMERS_XO_CLK_DIV_CFG not defined\n",
			vers);
		exit(1);
	} else if (version < IPA_VERSION_4_5) {
		printf("version %s TIMERS_XO_CLK_DIV_CFG should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s TIMERS_XO_CLK_DIV_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "TIMERS_XO_CLK_DIV_CFG")) {
		printf("version %s TIMERS_XO_CLK_DIV_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_TIMERS_XO_CLK_DIV_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_TIMERS_XO_CLK_DIV_CFG_OFFSET);
		exit(1);
	}

	mask = DIV_VALUE_FMASK;
	ipa_reg_test_fmask(reg, DIV_VALUE, mask);

	mask = DIV_ENABLE_FMASK;
	ipa_reg_test_fmask(reg, DIV_ENABLE, mask);
}

static void ipa_reg_test_timers_pulse_gran_cfg(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 mask;

	if (IPA_REG_TIMERS_PULSE_GRAN_CFG >= regs->reg_count) {
		if (version < IPA_VERSION_4_5)
			return;

		printf("version %s TIMERS_PULSE_GRAN_CFG > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_TIMERS_PULSE_GRAN_CFG];
	if (!reg) {
		if (version < IPA_VERSION_4_5)
			return;

		printf("version %s TIMERS_PULSE_GRAN_CFG not defined\n",
			vers);
		exit(1);
	} else if (version < IPA_VERSION_4_5) {
		printf("version %s TIMERS_PULSE_GRAN_CFG should not be defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s TIMERS_PULSE_GRAN_CFG has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "TIMERS_PULSE_GRAN_CFG")) {
		printf("version %s TIMERS_PULSE_GRAN_CFG has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_TIMERS_PULSE_GRAN_CFG_OFFSET) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_TIMERS_PULSE_GRAN_CFG_OFFSET);
		exit(1);
	}

	mask = GRAN_0_FMASK;
	ipa_reg_test_fmask(reg, PULSE_GRAN_0, mask);

	mask = GRAN_1_FMASK;
	ipa_reg_test_fmask(reg, PULSE_GRAN_1, mask);

	mask = GRAN_2_FMASK;
	ipa_reg_test_fmask(reg, PULSE_GRAN_2, mask);
}

static void
ipa_reg_test_src_rsrc_grp_01_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "SRC_RSRC_GRP_01_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_SRC_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_src_rsrc_grp_23_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "SRC_RSRC_GRP_23_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_SRC_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_src_rsrc_grp_45_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "SRC_RSRC_GRP_45_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_SRC_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_src_rsrc_grp_67_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "SRC_RSRC_GRP_67_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_SRC_RSRC_GRP_67_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_dst_rsrc_grp_01_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "DST_RSRC_GRP_01_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_DST_RSRC_GRP_01_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_dst_rsrc_grp_23_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "DST_RSRC_GRP_23_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_DST_RSRC_GRP_23_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_dst_rsrc_grp_45_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "DST_RSRC_GRP_45_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_DST_RSRC_GRP_45_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void
ipa_reg_test_dst_rsrc_grp_67_rsrc_type_n(enum ipa_version version)
{
	const struct ipa_regs *regs = ipa_regs[version];
	const char *vers = version_string(version);
	const struct ipa_reg *reg;
	u32 stride;
	u32 mask;

	if (IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N >= regs->reg_count) {
		printf("version %s IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N > reg_count %u\n",
			vers, regs->reg_count);
		exit(1);
	}

	reg = regs->reg[IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N];
	if (!reg) {
		printf("version %s IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N not defined\n",
			vers);
		exit(1);
	}

	if (!reg->name) {
		printf("version %s IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N has no defined name\n",
			vers);
		exit(1);
	}

	if (strcmp(reg->name, "DST_RSRC_GRP_67_RSRC_TYPE_N")) {
		printf("version %s IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N has wrong name %s\n",
			vers, reg->name);
		exit(1);
	}

	if (reg->offset != IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N_OFFSET(0)) {
		printf("version %s %s offset 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->offset,
			IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N_OFFSET(0));
		exit(1);
	}

	stride = IPA_REG_DST_RSRC_GRP_67_RSRC_TYPE_N_OFFSET(1) - reg->offset;
	if (reg->stride != stride) {
		printf("version %s %s stride 0x%04x, old 0x%04x\n",
			vers, reg->name, reg->stride, stride);
		exit(1);
	}

	mask = X_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MIN_LIM, mask);

	mask = X_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_X_MAX_LIM, mask);

	mask = Y_MIN_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MIN_LIM, mask);

	mask = Y_MAX_LIM_FMASK;
	ipa_reg_test_fmask(reg, RSRC_GRP_Y_MAX_LIM, mask);
}

static void ipa_reg_test_rsrc_grp_rsrc_type(enum ipa_version version)
{
	ipa_reg_test_src_rsrc_grp_01_rsrc_type_n(version);
	ipa_reg_test_src_rsrc_grp_23_rsrc_type_n(version);
	ipa_reg_test_src_rsrc_grp_45_rsrc_type_n(version);
	ipa_reg_test_src_rsrc_grp_67_rsrc_type_n(version);

	ipa_reg_test_dst_rsrc_grp_01_rsrc_type_n(version);
	ipa_reg_test_dst_rsrc_grp_23_rsrc_type_n(version);
	ipa_reg_test_dst_rsrc_grp_45_rsrc_type_n(version);
	ipa_reg_test_dst_rsrc_grp_67_rsrc_type_n(version);
}

static void ipa_reg_test(enum ipa_version version)
{
	printf("Testing %s\n", version_string(version));

	ipa_reg_test_comp_cfg(version);
	ipa_reg_test_clkon_cfg(version);
	ipa_reg_test_route(version);
	ipa_reg_test_shared_mem_size(version);
	ipa_reg_test_qsb_max_writes(version);
	ipa_reg_test_qsb_max_reads(version);
	ipa_reg_test_filt_rout_hash_en(version);
	ipa_reg_test_filt_rout_hash_flush(version);
	ipa_reg_test_state_aggr_active(version);
	ipa_reg_test_bcr(version);
	ipa_reg_test_local_pkt_proc_cntxt(version);
	ipa_reg_test_aggr_force_close(version);
	ipa_reg_test_counter_cfg(version);
	ipa_reg_test_tx_cfg(version);
	ipa_reg_test_flavor_0(version);
	ipa_reg_test_idle_indication_cfg(version);
	ipa_reg_test_qtime_timestamp_cfg(version);
	ipa_reg_test_timers_xo_clk_div_cfg(version);
	ipa_reg_test_timers_pulse_gran_cfg(version);
	ipa_reg_test_rsrc_grp_rsrc_type(version);
}

int ipa_reg_init(struct ipa *ipa)
{
	enum ipa_version version;

	for (version = 0; version < IPA_VERSION_COUNT; version++)
		ipa_reg_test(version);

	return 0;
}

void ipa_reg_exit(struct ipa *ipa)
{
}