/***********************license start************************************
 * Copyright (c) 2003-2017 Cavium, Inc.
 * All rights reserved.
 *
 * License: one of 'Cavium License' or 'GNU General Public License Version 2'
 *
 * This file is provided under the terms of the Cavium License (see below)
 * or under the terms of GNU General Public License, Version 2, as
 * published by the Free Software Foundation. When using or redistributing
 * this file, you may do so under either license.
 *
 * Cavium License:  Redistribution and use in source and binary forms, with
 * or without modification, are permitted provided that the following
 * conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *
 *  * Neither the name of Cavium Inc. nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * This Software, including technical data, may be subject to U.S. export
 * control laws, including the U.S. Export Administration Act and its
 * associated regulations, and may be subject to export or import
 * regulations in other countries.
 *
 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS
 * OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH
 * RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY
 * REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT
 * DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY)
 * WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A
 * PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET
 * ENJOYMENT, QUIET POSSESSION OR CORRESPONDENCE TO DESCRIPTION. THE
 * ENTIRE  RISK ARISING OUT OF USE OR PERFORMANCE OF THE SOFTWARE LIES
 * WITH YOU.
 ***********************license end**************************************/

#ifndef __ZIP_REGS_H__
#define __ZIP_REGS_H__

/*
 * Configuration and status register (CSR) address and type definitions for
 * Cavium ZIP.
 */

#include <linux/kern_levels.h>

/* ZIP invocation result completion status codes */
#define ZIP_CMD_NOTDONE        0x0

/* Successful completion. */
#define ZIP_CMD_SUCCESS        0x1

/* Output truncated */
#define ZIP_CMD_DTRUNC         0x2

/* Dynamic Stop */
#define ZIP_CMD_DYNAMIC_STOP   0x3

/* Uncompress ran out of input data when IWORD0[EF] was set */
#define ZIP_CMD_ITRUNC         0x4

/* Uncompress found the reserved block type 3 */
#define ZIP_CMD_RBLOCK         0x5

/*
 * Uncompress found LEN != ZIP_CMD_NLEN in an uncompressed block in the input.
 */
#define ZIP_CMD_NLEN           0x6

/* Uncompress found a bad code in the main Huffman codes. */
#define ZIP_CMD_BADCODE        0x7

/* Uncompress found a bad code in the 19 Huffman codes encoding lengths. */
#define ZIP_CMD_BADCODE2       0x8

/* Compress found a zero-length input. */
#define ZIP_CMD_ZERO_LEN       0x9

/* The compress or decompress encountered an internal parity error. */
#define ZIP_CMD_PARITY         0xA

/*
 * Uncompress found a string identifier that precedes the uncompressed data and
 * decompression history.
 */
#define ZIP_CMD_FATAL          0xB

/**
 * enum zip_int_vec_e - ZIP MSI-X Vector Enumeration, enumerates the MSI-X
 * interrupt vectors.
 */
enum zip_int_vec_e {
	ZIP_INT_VEC_E_ECCE = 0x10,
	ZIP_INT_VEC_E_FIFE = 0x11,
	ZIP_INT_VEC_E_QUE0_DONE = 0x0,
	ZIP_INT_VEC_E_QUE0_ERR = 0x8,
	ZIP_INT_VEC_E_QUE1_DONE = 0x1,
	ZIP_INT_VEC_E_QUE1_ERR = 0x9,
	ZIP_INT_VEC_E_QUE2_DONE = 0x2,
	ZIP_INT_VEC_E_QUE2_ERR = 0xa,
	ZIP_INT_VEC_E_QUE3_DONE = 0x3,
	ZIP_INT_VEC_E_QUE3_ERR = 0xb,
	ZIP_INT_VEC_E_QUE4_DONE = 0x4,
	ZIP_INT_VEC_E_QUE4_ERR = 0xc,
	ZIP_INT_VEC_E_QUE5_DONE = 0x5,
	ZIP_INT_VEC_E_QUE5_ERR = 0xd,
	ZIP_INT_VEC_E_QUE6_DONE = 0x6,
	ZIP_INT_VEC_E_QUE6_ERR = 0xe,
	ZIP_INT_VEC_E_QUE7_DONE = 0x7,
	ZIP_INT_VEC_E_QUE7_ERR = 0xf,
	ZIP_INT_VEC_E_ENUM_LAST = 0x12,
};

/**
 * union zip_zptr_addr_s - ZIP Generic Pointer Structure for ADDR.
 *
 * It is the generic format of pointers in ZIP_INST_S.
 */
union zip_zptr_addr_s {
	u64 u_reg64;
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_49_63              : 15;
		u64 addr                        : 49;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 addr                        : 49;
		u64 reserved_49_63              : 15;
#endif
	} s;

};

/**
 * union zip_zptr_ctl_s - ZIP Generic Pointer Structure for CTL.
 *
 * It is the generic format of pointers in ZIP_INST_S.
 */
union zip_zptr_ctl_s {
	u64 u_reg64;
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_112_127            : 16;
		u64 length                      : 16;
		u64 reserved_67_95              : 29;
		u64 fw                          : 1;
		u64 nc                          : 1;
		u64 data_be                     : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 data_be                     : 1;
		u64 nc                          : 1;
		u64 fw                          : 1;
		u64 reserved_67_95              : 29;
		u64 length                      : 16;
		u64 reserved_112_127            : 16;
#endif
	} s;
};

/**
 * union zip_inst_s - ZIP Instruction Structure.
 * Each ZIP instruction has 16 words (they are called IWORD0 to IWORD15 within
 * the structure).
 */
union zip_inst_s {
	u64 u_reg64[16];
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 doneint                     : 1;
		u64 reserved_56_62              : 7;
		u64 totaloutputlength           : 24;
		u64 reserved_27_31              : 5;
		u64 exn                         : 3;
		u64 reserved_23_23              : 1;
		u64 exbits                      : 7;
		u64 reserved_12_15              : 4;
		u64 sf                          : 1;
		u64 ss                          : 2;
		u64 cc                          : 2;
		u64 ef                          : 1;
		u64 bf                          : 1;
		u64 ce                          : 1;
		u64 reserved_3_3                : 1;
		u64 ds                          : 1;
		u64 dg                          : 1;
		u64 hg                          : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 hg                          : 1;
		u64 dg                          : 1;
		u64 ds                          : 1;
		u64 reserved_3_3                : 1;
		u64 ce                          : 1;
		u64 bf                          : 1;
		u64 ef                          : 1;
		u64 cc                          : 2;
		u64 ss                          : 2;
		u64 sf                          : 1;
		u64 reserved_12_15              : 4;
		u64 exbits                      : 7;
		u64 reserved_23_23              : 1;
		u64 exn                         : 3;
		u64 reserved_27_31              : 5;
		u64 totaloutputlength           : 24;
		u64 reserved_56_62              : 7;
		u64 doneint                     : 1;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 historylength               : 16;
		u64 reserved_96_111             : 16;
		u64 adlercrc32                  : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 adlercrc32                  : 32;
		u64 reserved_96_111             : 16;
		u64 historylength               : 16;
#endif
		union zip_zptr_addr_s ctx_ptr_addr;
		union zip_zptr_ctl_s ctx_ptr_ctl;
		union zip_zptr_addr_s his_ptr_addr;
		union zip_zptr_ctl_s his_ptr_ctl;
		union zip_zptr_addr_s inp_ptr_addr;
		union zip_zptr_ctl_s inp_ptr_ctl;
		union zip_zptr_addr_s out_ptr_addr;
		union zip_zptr_ctl_s out_ptr_ctl;
		union zip_zptr_addr_s res_ptr_addr;
		union zip_zptr_ctl_s res_ptr_ctl;
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_817_831            : 15;
		u64 wq_ptr                      : 49;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 wq_ptr                      : 49;
		u64 reserved_817_831            : 15;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_882_895            : 14;
		u64 tt                          : 2;
		u64 reserved_874_879            : 6;
		u64 grp                         : 10;
		u64 tag                         : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 tag                         : 32;
		u64 grp                         : 10;
		u64 reserved_874_879            : 6;
		u64 tt                          : 2;
		u64 reserved_882_895            : 14;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_896_959            : 64;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 reserved_896_959            : 64;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_960_1023           : 64;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 reserved_960_1023           : 64;
#endif
	} s;
};

/**
 * union zip_nptr_s - ZIP Instruction Next-Chunk-Buffer Pointer (NPTR)
 * Structure
 *
 * ZIP_NPTR structure is used to chain all the zip instruction buffers
 * together. ZIP instruction buffers are managed (allocated and released) by
 * the software.
 */
union zip_nptr_s {
	u64 u_reg64;
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_49_63              : 15;
		u64 addr                        : 49;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 addr                        : 49;
		u64 reserved_49_63              : 15;
#endif
	} s;
};

/**
 * union zip_zptr_s - ZIP Generic Pointer Structure.
 *
 * It is the generic format of pointers in ZIP_INST_S.
 */
union zip_zptr_s {
	u64 u_reg64[2];
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_49_63              : 15;
		u64 addr                        : 49;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 addr                        : 49;
		u64 reserved_49_63              : 15;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_112_127            : 16;
		u64 length                      : 16;
		u64 reserved_67_95              : 29;
		u64 fw                          : 1;
		u64 nc                          : 1;
		u64 data_be                     : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 data_be                     : 1;
		u64 nc                          : 1;
		u64 fw                          : 1;
		u64 reserved_67_95              : 29;
		u64 length                      : 16;
		u64 reserved_112_127            : 16;
#endif
	} s;
};

/**
 * union zip_zres_s - ZIP Result Structure
 *
 * The ZIP coprocessor writes the result structure after it completes the
 * invocation. The result structure is exactly 24 bytes, and each invocation of
 * the ZIP coprocessor produces exactly one result structure.
 */
union zip_zres_s {
	u64 u_reg64[3];
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 crc32                       : 32;
		u64 adler32                     : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 adler32                     : 32;
		u64 crc32                       : 32;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 totalbyteswritten           : 32;
		u64 totalbytesread              : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 totalbytesread              : 32;
		u64 totalbyteswritten           : 32;
#endif
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 totalbitsprocessed          : 32;
		u64 doneint                     : 1;
		u64 reserved_155_158            : 4;
		u64 exn                         : 3;
		u64 reserved_151_151            : 1;
		u64 exbits                      : 7;
		u64 reserved_137_143            : 7;
		u64 ef                          : 1;

		volatile u64 compcode           : 8;
#elif defined(__LITTLE_ENDIAN_BITFIELD)

		volatile u64 compcode           : 8;
		u64 ef                          : 1;
		u64 reserved_137_143            : 7;
		u64 exbits                      : 7;
		u64 reserved_151_151            : 1;
		u64 exn                         : 3;
		u64 reserved_155_158            : 4;
		u64 doneint                     : 1;
		u64 totalbitsprocessed          : 32;
#endif
	} s;
};

/**
 * union zip_cmd_ctl - Structure representing the register that controls
 * clock and reset.
 */
union zip_cmd_ctl {
	u64 u_reg64;
	struct zip_cmd_ctl_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_2_63               : 62;
		u64 forceclk                    : 1;
		u64 reset                       : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 reset                       : 1;
		u64 forceclk                    : 1;
		u64 reserved_2_63               : 62;
#endif
	} s;
};

#define ZIP_CMD_CTL 0x0ull

/**
 * union zip_constants - Data structure representing the register that contains
 * all of the current implementation-related parameters of the zip core in this
 * chip.
 */
union zip_constants {
	u64 u_reg64;
	struct zip_constants_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 nexec                       : 8;
		u64 reserved_49_55              : 7;
		u64 syncflush_capable           : 1;
		u64 depth                       : 16;
		u64 onfsize                     : 12;
		u64 ctxsize                     : 12;
		u64 reserved_1_7                : 7;
		u64 disabled                    : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 disabled                    : 1;
		u64 reserved_1_7                : 7;
		u64 ctxsize                     : 12;
		u64 onfsize                     : 12;
		u64 depth                       : 16;
		u64 syncflush_capable           : 1;
		u64 reserved_49_55              : 7;
		u64 nexec                       : 8;
#endif
	} s;
};

#define ZIP_CONSTANTS 0x00A0ull

/**
 * union zip_corex_bist_status - Represents registers which have the BIST
 * status of memories in zip cores.
 *
 * Each bit is the BIST result of an individual memory
 * (per bit, 0 = pass and 1 = fail).
 */
union zip_corex_bist_status {
	u64 u_reg64;
	struct zip_corex_bist_status_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_53_63              : 11;
		u64 bstatus                     : 53;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 bstatus                     : 53;
		u64 reserved_53_63              : 11;
#endif
	} s;
};

static inline u64 ZIP_COREX_BIST_STATUS(u64 param1)
{
	if (((param1 <= 1)))
		return 0x0520ull + (param1 & 1) * 0x8ull;
	pr_err("ZIP_COREX_BIST_STATUS: %llu\n", param1);
	return 0;
}

/**
 * union zip_ctl_bist_status - Represents register that has the BIST status of
 * memories in ZIP_CTL (instruction buffer, G/S pointer FIFO, input data
 * buffer, output data buffers).
 *
 * Each bit is the BIST result of an individual memory
 * (per bit, 0 = pass and 1 = fail).
 */
union zip_ctl_bist_status {
	u64 u_reg64;
	struct zip_ctl_bist_status_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_9_63               : 55;
		u64 bstatus                     : 9;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 bstatus                     : 9;
		u64 reserved_9_63               : 55;
#endif
	} s;
};

#define ZIP_CTL_BIST_STATUS 0x0510ull

/**
 * union zip_ctl_cfg - Represents the register that controls the behavior of
 * the ZIP DMA engines.
 *
 * It is recommended to keep default values for normal operation. Changing the
 * values of the fields may be useful for diagnostics.
 */
union zip_ctl_cfg {
	u64 u_reg64;
	struct zip_ctl_cfg_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_52_63              : 12;
		u64 ildf                        : 4;
		u64 reserved_36_47              : 12;
		u64 drtf                        : 4;
		u64 reserved_27_31              : 5;
		u64 stcf                        : 3;
		u64 reserved_19_23              : 5;
		u64 ldf                         : 3;
		u64 reserved_2_15               : 14;
		u64 busy                        : 1;
		u64 reserved_0_0                : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 reserved_0_0                : 1;
		u64 busy                        : 1;
		u64 reserved_2_15               : 14;
		u64 ldf                         : 3;
		u64 reserved_19_23              : 5;
		u64 stcf                        : 3;
		u64 reserved_27_31              : 5;
		u64 drtf                        : 4;
		u64 reserved_36_47              : 12;
		u64 ildf                        : 4;
		u64 reserved_52_63              : 12;
#endif
	} s;
};

#define ZIP_CTL_CFG 0x0560ull

/**
 * union zip_dbg_corex_inst - Represents the registers that reflect the status
 * of the current instruction that the ZIP core is executing or has executed.
 *
 * These registers are only for debug use.
 */
union zip_dbg_corex_inst {
	u64 u_reg64;
	struct zip_dbg_corex_inst_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 busy                        : 1;
		u64 reserved_35_62              : 28;
		u64 qid                         : 3;
		u64 iid                         : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 iid                         : 32;
		u64 qid                         : 3;
		u64 reserved_35_62              : 28;
		u64 busy                        : 1;
#endif
	} s;
};

static inline u64 ZIP_DBG_COREX_INST(u64 param1)
{
	if (((param1 <= 1)))
		return 0x0640ull + (param1 & 1) * 0x8ull;
	pr_err("ZIP_DBG_COREX_INST: %llu\n", param1);
	return 0;
}

/**
 * union zip_dbg_corex_sta - Represents registers that reflect the status of
 * the zip cores.
 *
 * They are for debug use only.
 */
union zip_dbg_corex_sta {
	u64 u_reg64;
	struct zip_dbg_corex_sta_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 busy                        : 1;
		u64 reserved_37_62              : 26;
		u64 ist                         : 5;
		u64 nie                         : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 nie                         : 32;
		u64 ist                         : 5;
		u64 reserved_37_62              : 26;
		u64 busy                        : 1;
#endif
	} s;
};

static inline u64 ZIP_DBG_COREX_STA(u64 param1)
{
	if (((param1 <= 1)))
		return 0x0680ull + (param1 & 1) * 0x8ull;
	pr_err("ZIP_DBG_COREX_STA: %llu\n", param1);
	return 0;
}

/**
 * union zip_dbg_quex_sta - Represets registers that reflect status of the zip
 * instruction queues.
 *
 * They are for debug use only.
 */
union zip_dbg_quex_sta {
	u64 u_reg64;
	struct zip_dbg_quex_sta_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 busy                        : 1;
		u64 reserved_56_62              : 7;
		u64 rqwc                        : 24;
		u64 nii                         : 32;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 nii                         : 32;
		u64 rqwc                        : 24;
		u64 reserved_56_62              : 7;
		u64 busy                        : 1;
#endif
	} s;
};

static inline u64 ZIP_DBG_QUEX_STA(u64 param1)
{
	if (((param1 <= 7)))
		return 0x1800ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_DBG_QUEX_STA: %llu\n", param1);
	return 0;
}

/**
 * union zip_ecc_ctl - Represents the register that enables ECC for each
 * individual internal memory that requires ECC.
 *
 * For debug purpose, it can also flip one or two bits in the ECC data.
 */
union zip_ecc_ctl {
	u64 u_reg64;
	struct zip_ecc_ctl_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_19_63              : 45;
		u64 vmem_cdis                   : 1;
		u64 vmem_fs                     : 2;
		u64 reserved_15_15              : 1;
		u64 idf1_cdis                   : 1;
		u64 idf1_fs                     : 2;
		u64 reserved_11_11              : 1;
		u64 idf0_cdis                   : 1;
		u64 idf0_fs                     : 2;
		u64 reserved_7_7                : 1;
		u64 gspf_cdis                   : 1;
		u64 gspf_fs                     : 2;
		u64 reserved_3_3                : 1;
		u64 iqf_cdis                    : 1;
		u64 iqf_fs                      : 2;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 iqf_fs                      : 2;
		u64 iqf_cdis                    : 1;
		u64 reserved_3_3                : 1;
		u64 gspf_fs                     : 2;
		u64 gspf_cdis                   : 1;
		u64 reserved_7_7                : 1;
		u64 idf0_fs                     : 2;
		u64 idf0_cdis                   : 1;
		u64 reserved_11_11              : 1;
		u64 idf1_fs                     : 2;
		u64 idf1_cdis                   : 1;
		u64 reserved_15_15              : 1;
		u64 vmem_fs                     : 2;
		u64 vmem_cdis                   : 1;
		u64 reserved_19_63              : 45;
#endif
	} s;
};

#define ZIP_ECC_CTL 0x0568ull

/* NCB - zip_ecce_ena_w1c */
union zip_ecce_ena_w1c {
	u64 u_reg64;
	struct zip_ecce_ena_w1c_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_37_63              : 27;
		u64 dbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 sbe                         : 5;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 sbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 dbe                         : 5;
		u64 reserved_37_63              : 27;
#endif
	} s;
};

#define ZIP_ECCE_ENA_W1C 0x0598ull

/* NCB - zip_ecce_ena_w1s */
union zip_ecce_ena_w1s {
	u64 u_reg64;
	struct zip_ecce_ena_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_37_63              : 27;
		u64 dbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 sbe                         : 5;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 sbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 dbe                         : 5;
		u64 reserved_37_63              : 27;
#endif
	} s;
};

#define ZIP_ECCE_ENA_W1S 0x0590ull

/**
 * union zip_ecce_int - Represents the register that contains the status of the
 * ECC interrupt sources.
 */
union zip_ecce_int {
	u64 u_reg64;
	struct zip_ecce_int_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_37_63              : 27;
		u64 dbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 sbe                         : 5;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 sbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 dbe                         : 5;
		u64 reserved_37_63              : 27;
#endif
	} s;
};

#define ZIP_ECCE_INT 0x0580ull

/* NCB - zip_ecce_int_w1s */
union zip_ecce_int_w1s {
	u64 u_reg64;
	struct zip_ecce_int_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_37_63              : 27;
		u64 dbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 sbe                         : 5;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 sbe                         : 5;
		u64 reserved_5_31               : 27;
		u64 dbe                         : 5;
		u64 reserved_37_63              : 27;
#endif
	} s;
};

#define ZIP_ECCE_INT_W1S 0x0588ull

/* NCB - zip_fife_ena_w1c */
union zip_fife_ena_w1c {
	u64 u_reg64;
	struct zip_fife_ena_w1c_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_42_63              : 22;
		u64 asserts                     : 42;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 asserts                     : 42;
		u64 reserved_42_63              : 22;
#endif
	} s;
};

#define ZIP_FIFE_ENA_W1C 0x0090ull

/* NCB - zip_fife_ena_w1s */
union zip_fife_ena_w1s {
	u64 u_reg64;
	struct zip_fife_ena_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_42_63              : 22;
		u64 asserts                     : 42;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 asserts                     : 42;
		u64 reserved_42_63              : 22;
#endif
	} s;
};

#define ZIP_FIFE_ENA_W1S 0x0088ull

/* NCB - zip_fife_int */
union zip_fife_int {
	u64 u_reg64;
	struct zip_fife_int_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_42_63              : 22;
		u64 asserts                     : 42;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 asserts                     : 42;
		u64 reserved_42_63              : 22;
#endif
	} s;
};

#define ZIP_FIFE_INT 0x0078ull

/* NCB - zip_fife_int_w1s */
union zip_fife_int_w1s {
	u64 u_reg64;
	struct zip_fife_int_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_42_63              : 22;
		u64 asserts                     : 42;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 asserts                     : 42;
		u64 reserved_42_63              : 22;
#endif
	} s;
};

#define ZIP_FIFE_INT_W1S 0x0080ull

/**
 * union zip_msix_pbax - Represents the register that is the MSI-X PBA table
 *
 * The bit number is indexed by the ZIP_INT_VEC_E enumeration.
 */
union zip_msix_pbax {
	u64 u_reg64;
	struct zip_msix_pbax_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 pend                        : 64;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 pend                        : 64;
#endif
	} s;
};

static inline u64 ZIP_MSIX_PBAX(u64 param1)
{
	if (((param1 == 0)))
		return 0x0000838000FF0000ull;
	pr_err("ZIP_MSIX_PBAX: %llu\n", param1);
	return 0;
}

/**
 * union zip_msix_vecx_addr - Represents the register that is the MSI-X vector
 * table, indexed by the ZIP_INT_VEC_E enumeration.
 */
union zip_msix_vecx_addr {
	u64 u_reg64;
	struct zip_msix_vecx_addr_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_49_63              : 15;
		u64 addr                        : 47;
		u64 reserved_1_1                : 1;
		u64 secvec                      : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 secvec                      : 1;
		u64 reserved_1_1                : 1;
		u64 addr                        : 47;
		u64 reserved_49_63              : 15;
#endif
	} s;
};

static inline u64 ZIP_MSIX_VECX_ADDR(u64 param1)
{
	if (((param1 <= 17)))
		return 0x0000838000F00000ull + (param1 & 31) * 0x10ull;
	pr_err("ZIP_MSIX_VECX_ADDR: %llu\n", param1);
	return 0;
}

/**
 * union zip_msix_vecx_ctl - Represents the register that is the MSI-X vector
 * table, indexed by the ZIP_INT_VEC_E enumeration.
 */
union zip_msix_vecx_ctl {
	u64 u_reg64;
	struct zip_msix_vecx_ctl_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_33_63              : 31;
		u64 mask                        : 1;
		u64 reserved_20_31              : 12;
		u64 data                        : 20;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 data                        : 20;
		u64 reserved_20_31              : 12;
		u64 mask                        : 1;
		u64 reserved_33_63              : 31;
#endif
	} s;
};

static inline u64 ZIP_MSIX_VECX_CTL(u64 param1)
{
	if (((param1 <= 17)))
		return 0x0000838000F00008ull + (param1 & 31) * 0x10ull;
	pr_err("ZIP_MSIX_VECX_CTL: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_done - Represents the registers that contain the per-queue
 * instruction done count.
 */
union zip_quex_done {
	u64 u_reg64;
	struct zip_quex_done_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_20_63              : 44;
		u64 done                        : 20;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 done                        : 20;
		u64 reserved_20_63              : 44;
#endif
	} s;
};

static inline u64 ZIP_QUEX_DONE(u64 param1)
{
	if (((param1 <= 7)))
		return 0x2000ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_DONE: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_done_ack - Represents the registers on write to which will
 * decrement the per-queue instructiona done count.
 */
union zip_quex_done_ack {
	u64 u_reg64;
	struct zip_quex_done_ack_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_20_63              : 44;
		u64 done_ack                    : 20;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 done_ack                    : 20;
		u64 reserved_20_63              : 44;
#endif
	} s;
};

static inline u64 ZIP_QUEX_DONE_ACK(u64 param1)
{
	if (((param1 <= 7)))
		return 0x2200ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_DONE_ACK: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_done_ena_w1c - Represents the register which when written
 * 1 to will disable the DONEINT interrupt for the queue.
 */
union zip_quex_done_ena_w1c {
	u64 u_reg64;
	struct zip_quex_done_ena_w1c_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_1_63               : 63;
		u64 done_ena                    : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 done_ena                    : 1;
		u64 reserved_1_63               : 63;
#endif
	} s;
};

static inline u64 ZIP_QUEX_DONE_ENA_W1C(u64 param1)
{
	if (((param1 <= 7)))
		return 0x2600ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_DONE_ENA_W1C: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_done_ena_w1s - Represents the register that when written 1 to
 * will enable the DONEINT interrupt for the queue.
 */
union zip_quex_done_ena_w1s {
	u64 u_reg64;
	struct zip_quex_done_ena_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_1_63               : 63;
		u64 done_ena                    : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 done_ena                    : 1;
		u64 reserved_1_63               : 63;
#endif
	} s;
};

static inline u64 ZIP_QUEX_DONE_ENA_W1S(u64 param1)
{
	if (((param1 <= 7)))
		return 0x2400ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_DONE_ENA_W1S: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_done_wait - Represents the register that specifies the per
 * queue interrupt coalescing settings.
 */
union zip_quex_done_wait {
	u64 u_reg64;
	struct zip_quex_done_wait_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_48_63              : 16;
		u64 time_wait                   : 16;
		u64 reserved_20_31              : 12;
		u64 num_wait                    : 20;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 num_wait                    : 20;
		u64 reserved_20_31              : 12;
		u64 time_wait                   : 16;
		u64 reserved_48_63              : 16;
#endif
	} s;
};

static inline u64 ZIP_QUEX_DONE_WAIT(u64 param1)
{
	if (((param1 <= 7)))
		return 0x2800ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_DONE_WAIT: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_doorbell - Represents doorbell registers for the ZIP
 * instruction queues.
 */
union zip_quex_doorbell {
	u64 u_reg64;
	struct zip_quex_doorbell_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_20_63              : 44;
		u64 dbell_cnt                   : 20;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 dbell_cnt                   : 20;
		u64 reserved_20_63              : 44;
#endif
	} s;
};

static inline u64 ZIP_QUEX_DOORBELL(u64 param1)
{
	if (((param1 <= 7)))
		return 0x4000ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_DOORBELL: %llu\n", param1);
	return 0;
}

union zip_quex_err_ena_w1c {
	u64 u_reg64;
	struct zip_quex_err_ena_w1c_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_5_63               : 59;
		u64 mdbe                        : 1;
		u64 nwrp                        : 1;
		u64 nrrp                        : 1;
		u64 irde                        : 1;
		u64 dovf                        : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 dovf                        : 1;
		u64 irde                        : 1;
		u64 nrrp                        : 1;
		u64 nwrp                        : 1;
		u64 mdbe                        : 1;
		u64 reserved_5_63               : 59;
#endif
	} s;
};

static inline u64 ZIP_QUEX_ERR_ENA_W1C(u64 param1)
{
	if (((param1 <= 7)))
		return 0x3600ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_ERR_ENA_W1C: %llu\n", param1);
	return 0;
}

union zip_quex_err_ena_w1s {
	u64 u_reg64;
	struct zip_quex_err_ena_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_5_63               : 59;
		u64 mdbe                        : 1;
		u64 nwrp                        : 1;
		u64 nrrp                        : 1;
		u64 irde                        : 1;
		u64 dovf                        : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 dovf                        : 1;
		u64 irde                        : 1;
		u64 nrrp                        : 1;
		u64 nwrp                        : 1;
		u64 mdbe                        : 1;
		u64 reserved_5_63               : 59;
#endif
	} s;
};

static inline u64 ZIP_QUEX_ERR_ENA_W1S(u64 param1)
{
	if (((param1 <= 7)))
		return 0x3400ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_ERR_ENA_W1S: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_err_int - Represents registers that contain the per-queue
 * error interrupts.
 */
union zip_quex_err_int {
	u64 u_reg64;
	struct zip_quex_err_int_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_5_63               : 59;
		u64 mdbe                        : 1;
		u64 nwrp                        : 1;
		u64 nrrp                        : 1;
		u64 irde                        : 1;
		u64 dovf                        : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 dovf                        : 1;
		u64 irde                        : 1;
		u64 nrrp                        : 1;
		u64 nwrp                        : 1;
		u64 mdbe                        : 1;
		u64 reserved_5_63               : 59;
#endif
	} s;
};

static inline u64 ZIP_QUEX_ERR_INT(u64 param1)
{
	if (((param1 <= 7)))
		return 0x3000ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_ERR_INT: %llu\n", param1);
	return 0;
}

/* NCB - zip_que#_err_int_w1s */
union zip_quex_err_int_w1s {
	u64 u_reg64;
	struct zip_quex_err_int_w1s_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_5_63               : 59;
		u64 mdbe                        : 1;
		u64 nwrp                        : 1;
		u64 nrrp                        : 1;
		u64 irde                        : 1;
		u64 dovf                        : 1;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 dovf                        : 1;
		u64 irde                        : 1;
		u64 nrrp                        : 1;
		u64 nwrp                        : 1;
		u64 mdbe                        : 1;
		u64 reserved_5_63               : 59;
#endif
	} s;
};

static inline u64 ZIP_QUEX_ERR_INT_W1S(u64 param1)
{
	if (((param1 <= 7)))
		return 0x3200ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_ERR_INT_W1S: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_gcfg - Represents the registers that reflect status of the
 * zip instruction queues,debug use only.
 */
union zip_quex_gcfg {
	u64 u_reg64;
	struct zip_quex_gcfg_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_4_63               : 60;
		u64 iqb_ldwb                    : 1;
		u64 cbw_sty                     : 1;
		u64 l2ld_cmd                    : 2;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 l2ld_cmd                    : 2;
		u64 cbw_sty                     : 1;
		u64 iqb_ldwb                    : 1;
		u64 reserved_4_63               : 60;
#endif
	} s;
};

static inline u64 ZIP_QUEX_GCFG(u64 param1)
{
	if (((param1 <= 7)))
		return 0x1A00ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_GCFG: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_map - Represents the registers that control how each
 * instruction queue maps to zip cores.
 */
union zip_quex_map {
	u64 u_reg64;
	struct zip_quex_map_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_2_63               : 62;
		u64 zce                         : 2;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 zce                         : 2;
		u64 reserved_2_63               : 62;
#endif
	} s;
};

static inline u64 ZIP_QUEX_MAP(u64 param1)
{
	if (((param1 <= 7)))
		return 0x1400ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_MAP: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_sbuf_addr - Represents the registers that set the buffer
 * parameters for the instruction queues.
 *
 * When quiescent (i.e. outstanding doorbell count is 0), it is safe to rewrite
 * this register to effectively reset the command buffer state machine.
 * These registers must be programmed after SW programs the corresponding
 * ZIP_QUE(0..7)_SBUF_CTL.
 */
union zip_quex_sbuf_addr {
	u64 u_reg64;
	struct zip_quex_sbuf_addr_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_49_63              : 15;
		u64 ptr                         : 42;
		u64 off                         : 7;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 off                         : 7;
		u64 ptr                         : 42;
		u64 reserved_49_63              : 15;
#endif
	} s;
};

static inline u64 ZIP_QUEX_SBUF_ADDR(u64 param1)
{
	if (((param1 <= 7)))
		return 0x1000ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_SBUF_ADDR: %llu\n", param1);
	return 0;
}

/**
 * union zip_quex_sbuf_ctl - Represents the registers that set the buffer
 * parameters for the instruction queues.
 *
 * When quiescent (i.e. outstanding doorbell count is 0), it is safe to rewrite
 * this register to effectively reset the command buffer state machine.
 * These registers must be programmed before SW programs the corresponding
 * ZIP_QUE(0..7)_SBUF_ADDR.
 */
union zip_quex_sbuf_ctl {
	u64 u_reg64;
	struct zip_quex_sbuf_ctl_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_45_63              : 19;
		u64 size                        : 13;
		u64 inst_be                     : 1;
		u64 reserved_24_30              : 7;
		u64 stream_id                   : 8;
		u64 reserved_12_15              : 4;
		u64 aura                        : 12;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 aura                        : 12;
		u64 reserved_12_15              : 4;
		u64 stream_id                   : 8;
		u64 reserved_24_30              : 7;
		u64 inst_be                     : 1;
		u64 size                        : 13;
		u64 reserved_45_63              : 19;
#endif
	} s;
};

static inline u64 ZIP_QUEX_SBUF_CTL(u64 param1)
{
	if (((param1 <= 7)))
		return 0x1200ull + (param1 & 7) * 0x8ull;
	pr_err("ZIP_QUEX_SBUF_CTL: %llu\n", param1);
	return 0;
}

/**
 * union zip_que_ena - Represents queue enable register
 *
 * If a queue is disabled, ZIP_CTL stops fetching instructions from the queue.
 */
union zip_que_ena {
	u64 u_reg64;
	struct zip_que_ena_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_8_63               : 56;
		u64 ena                         : 8;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 ena                         : 8;
		u64 reserved_8_63               : 56;
#endif
	} s;
};

#define ZIP_QUE_ENA 0x0500ull

/**
 * union zip_que_pri - Represents the register that defines the priority
 * between instruction queues.
 */
union zip_que_pri {
	u64 u_reg64;
	struct zip_que_pri_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_8_63               : 56;
		u64 pri                         : 8;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 pri                         : 8;
		u64 reserved_8_63               : 56;
#endif
	} s;
};

#define ZIP_QUE_PRI 0x0508ull

/**
 * union zip_throttle - Represents the register that controls the maximum
 * number of in-flight X2I data fetch transactions.
 *
 * Writing 0 to this register causes the ZIP module to temporarily suspend NCB
 * accesses; it is not recommended for normal operation, but may be useful for
 * diagnostics.
 */
union zip_throttle {
	u64 u_reg64;
	struct zip_throttle_s {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 reserved_6_63               : 58;
		u64 ld_infl                     : 6;
#elif defined(__LITTLE_ENDIAN_BITFIELD)
		u64 ld_infl                     : 6;
		u64 reserved_6_63               : 58;
#endif
	} s;
};

#define ZIP_THROTTLE 0x0010ull

#endif /* _CSRS_ZIP__ */
