1348 lines
38 KiB
C
1348 lines
38 KiB
C
/***********************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__ */
|