path: root/cvmx-dfa-defs.h

/***********************license start***************
 * Copyright (c) 2003-2010  Cavium Networks (support@cavium.com). All rights
 * reserved.
 *
 *
 * 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 Networks 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  NETWORKS 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**************************************/


/**
 * cvmx-dfa-defs.h
 *
 * Configuration and status register (CSR) type definitions for
 * Octeon dfa.
 *
 * This file is auto generated. Do not edit.
 *
 * <hr>$Revision$<hr>
 *
 */
#ifndef __CVMX_DFA_TYPEDEFS_H__
#define __CVMX_DFA_TYPEDEFS_H__

#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_BIST0 CVMX_DFA_BIST0_FUNC()
static inline uint64_t CVMX_DFA_BIST0_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_BIST0 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370007F0ull);
}
#else
#define CVMX_DFA_BIST0 (CVMX_ADD_IO_SEG(0x00011800370007F0ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_BIST1 CVMX_DFA_BIST1_FUNC()
static inline uint64_t CVMX_DFA_BIST1_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_BIST1 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370007F8ull);
}
#else
#define CVMX_DFA_BIST1 (CVMX_ADD_IO_SEG(0x00011800370007F8ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_BST0 CVMX_DFA_BST0_FUNC()
static inline uint64_t CVMX_DFA_BST0_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_BST0 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800300007F0ull);
}
#else
#define CVMX_DFA_BST0 (CVMX_ADD_IO_SEG(0x00011800300007F0ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_BST1 CVMX_DFA_BST1_FUNC()
static inline uint64_t CVMX_DFA_BST1_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_BST1 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800300007F8ull);
}
#else
#define CVMX_DFA_BST1 (CVMX_ADD_IO_SEG(0x00011800300007F8ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_CFG CVMX_DFA_CFG_FUNC()
static inline uint64_t CVMX_DFA_CFG_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_CFG not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000000ull);
}
#else
#define CVMX_DFA_CFG (CVMX_ADD_IO_SEG(0x0001180030000000ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_CONFIG CVMX_DFA_CONFIG_FUNC()
static inline uint64_t CVMX_DFA_CONFIG_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_CONFIG not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000000ull);
}
#else
#define CVMX_DFA_CONFIG (CVMX_ADD_IO_SEG(0x0001180037000000ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_CONTROL CVMX_DFA_CONTROL_FUNC()
static inline uint64_t CVMX_DFA_CONTROL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_CONTROL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000020ull);
}
#else
#define CVMX_DFA_CONTROL (CVMX_ADD_IO_SEG(0x0001180037000020ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DBELL CVMX_DFA_DBELL_FUNC()
static inline uint64_t CVMX_DFA_DBELL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX) || OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DBELL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001370000000000ull);
}
#else
#define CVMX_DFA_DBELL (CVMX_ADD_IO_SEG(0x0001370000000000ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_ADDR CVMX_DFA_DDR2_ADDR_FUNC()
static inline uint64_t CVMX_DFA_DDR2_ADDR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_ADDR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000210ull);
}
#else
#define CVMX_DFA_DDR2_ADDR (CVMX_ADD_IO_SEG(0x0001180030000210ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_BUS CVMX_DFA_DDR2_BUS_FUNC()
static inline uint64_t CVMX_DFA_DDR2_BUS_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_BUS not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000080ull);
}
#else
#define CVMX_DFA_DDR2_BUS (CVMX_ADD_IO_SEG(0x0001180030000080ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_CFG CVMX_DFA_DDR2_CFG_FUNC()
static inline uint64_t CVMX_DFA_DDR2_CFG_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_CFG not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000208ull);
}
#else
#define CVMX_DFA_DDR2_CFG (CVMX_ADD_IO_SEG(0x0001180030000208ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_COMP CVMX_DFA_DDR2_COMP_FUNC()
static inline uint64_t CVMX_DFA_DDR2_COMP_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_COMP not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000090ull);
}
#else
#define CVMX_DFA_DDR2_COMP (CVMX_ADD_IO_SEG(0x0001180030000090ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_EMRS CVMX_DFA_DDR2_EMRS_FUNC()
static inline uint64_t CVMX_DFA_DDR2_EMRS_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_EMRS not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000268ull);
}
#else
#define CVMX_DFA_DDR2_EMRS (CVMX_ADD_IO_SEG(0x0001180030000268ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_FCNT CVMX_DFA_DDR2_FCNT_FUNC()
static inline uint64_t CVMX_DFA_DDR2_FCNT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_FCNT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000078ull);
}
#else
#define CVMX_DFA_DDR2_FCNT (CVMX_ADD_IO_SEG(0x0001180030000078ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_MRS CVMX_DFA_DDR2_MRS_FUNC()
static inline uint64_t CVMX_DFA_DDR2_MRS_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_MRS not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000260ull);
}
#else
#define CVMX_DFA_DDR2_MRS (CVMX_ADD_IO_SEG(0x0001180030000260ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_OPT CVMX_DFA_DDR2_OPT_FUNC()
static inline uint64_t CVMX_DFA_DDR2_OPT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_OPT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000070ull);
}
#else
#define CVMX_DFA_DDR2_OPT (CVMX_ADD_IO_SEG(0x0001180030000070ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_PLL CVMX_DFA_DDR2_PLL_FUNC()
static inline uint64_t CVMX_DFA_DDR2_PLL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_PLL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000088ull);
}
#else
#define CVMX_DFA_DDR2_PLL (CVMX_ADD_IO_SEG(0x0001180030000088ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DDR2_TMG CVMX_DFA_DDR2_TMG_FUNC()
static inline uint64_t CVMX_DFA_DDR2_TMG_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_DDR2_TMG not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000218ull);
}
#else
#define CVMX_DFA_DDR2_TMG (CVMX_ADD_IO_SEG(0x0001180030000218ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DEBUG0 CVMX_DFA_DEBUG0_FUNC()
static inline uint64_t CVMX_DFA_DEBUG0_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DEBUG0 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000040ull);
}
#else
#define CVMX_DFA_DEBUG0 (CVMX_ADD_IO_SEG(0x0001180037000040ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DEBUG1 CVMX_DFA_DEBUG1_FUNC()
static inline uint64_t CVMX_DFA_DEBUG1_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DEBUG1 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000048ull);
}
#else
#define CVMX_DFA_DEBUG1 (CVMX_ADD_IO_SEG(0x0001180037000048ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DEBUG2 CVMX_DFA_DEBUG2_FUNC()
static inline uint64_t CVMX_DFA_DEBUG2_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DEBUG2 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000050ull);
}
#else
#define CVMX_DFA_DEBUG2 (CVMX_ADD_IO_SEG(0x0001180037000050ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DEBUG3 CVMX_DFA_DEBUG3_FUNC()
static inline uint64_t CVMX_DFA_DEBUG3_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DEBUG3 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000058ull);
}
#else
#define CVMX_DFA_DEBUG3 (CVMX_ADD_IO_SEG(0x0001180037000058ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DIFCTL CVMX_DFA_DIFCTL_FUNC()
static inline uint64_t CVMX_DFA_DIFCTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX) || OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DIFCTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001370600000000ull);
}
#else
#define CVMX_DFA_DIFCTL (CVMX_ADD_IO_SEG(0x0001370600000000ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DIFRDPTR CVMX_DFA_DIFRDPTR_FUNC()
static inline uint64_t CVMX_DFA_DIFRDPTR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX) || OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DIFRDPTR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001370200000000ull);
}
#else
#define CVMX_DFA_DIFRDPTR (CVMX_ADD_IO_SEG(0x0001370200000000ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_DTCFADR CVMX_DFA_DTCFADR_FUNC()
static inline uint64_t CVMX_DFA_DTCFADR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_DTCFADR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000060ull);
}
#else
#define CVMX_DFA_DTCFADR (CVMX_ADD_IO_SEG(0x0001180037000060ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_ECLKCFG CVMX_DFA_ECLKCFG_FUNC()
static inline uint64_t CVMX_DFA_ECLKCFG_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX)))
		cvmx_warn("CVMX_DFA_ECLKCFG not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000200ull);
}
#else
#define CVMX_DFA_ECLKCFG (CVMX_ADD_IO_SEG(0x0001180030000200ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_ERR CVMX_DFA_ERR_FUNC()
static inline uint64_t CVMX_DFA_ERR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_ERR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000028ull);
}
#else
#define CVMX_DFA_ERR (CVMX_ADD_IO_SEG(0x0001180030000028ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_ERROR CVMX_DFA_ERROR_FUNC()
static inline uint64_t CVMX_DFA_ERROR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_ERROR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000028ull);
}
#else
#define CVMX_DFA_ERROR (CVMX_ADD_IO_SEG(0x0001180037000028ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_INTMSK CVMX_DFA_INTMSK_FUNC()
static inline uint64_t CVMX_DFA_INTMSK_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_INTMSK not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000030ull);
}
#else
#define CVMX_DFA_INTMSK (CVMX_ADD_IO_SEG(0x0001180037000030ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMCFG0 CVMX_DFA_MEMCFG0_FUNC()
static inline uint64_t CVMX_DFA_MEMCFG0_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_MEMCFG0 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000008ull);
}
#else
#define CVMX_DFA_MEMCFG0 (CVMX_ADD_IO_SEG(0x0001180030000008ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMCFG1 CVMX_DFA_MEMCFG1_FUNC()
static inline uint64_t CVMX_DFA_MEMCFG1_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_MEMCFG1 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000010ull);
}
#else
#define CVMX_DFA_MEMCFG1 (CVMX_ADD_IO_SEG(0x0001180030000010ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMCFG2 CVMX_DFA_MEMCFG2_FUNC()
static inline uint64_t CVMX_DFA_MEMCFG2_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_MEMCFG2 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000060ull);
}
#else
#define CVMX_DFA_MEMCFG2 (CVMX_ADD_IO_SEG(0x0001180030000060ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMFADR CVMX_DFA_MEMFADR_FUNC()
static inline uint64_t CVMX_DFA_MEMFADR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_MEMFADR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000030ull);
}
#else
#define CVMX_DFA_MEMFADR (CVMX_ADD_IO_SEG(0x0001180030000030ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMFCR CVMX_DFA_MEMFCR_FUNC()
static inline uint64_t CVMX_DFA_MEMFCR_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_MEMFCR not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000038ull);
}
#else
#define CVMX_DFA_MEMFCR (CVMX_ADD_IO_SEG(0x0001180030000038ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMHIDAT CVMX_DFA_MEMHIDAT_FUNC()
static inline uint64_t CVMX_DFA_MEMHIDAT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_MEMHIDAT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001370700000000ull);
}
#else
#define CVMX_DFA_MEMHIDAT (CVMX_ADD_IO_SEG(0x0001370700000000ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_MEMRLD CVMX_DFA_MEMRLD_FUNC()
static inline uint64_t CVMX_DFA_MEMRLD_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_MEMRLD not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000018ull);
}
#else
#define CVMX_DFA_MEMRLD (CVMX_ADD_IO_SEG(0x0001180030000018ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_NCBCTL CVMX_DFA_NCBCTL_FUNC()
static inline uint64_t CVMX_DFA_NCBCTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_NCBCTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000020ull);
}
#else
#define CVMX_DFA_NCBCTL (CVMX_ADD_IO_SEG(0x0001180030000020ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC0_CNT CVMX_DFA_PFC0_CNT_FUNC()
static inline uint64_t CVMX_DFA_PFC0_CNT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC0_CNT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000090ull);
}
#else
#define CVMX_DFA_PFC0_CNT (CVMX_ADD_IO_SEG(0x0001180037000090ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC0_CTL CVMX_DFA_PFC0_CTL_FUNC()
static inline uint64_t CVMX_DFA_PFC0_CTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC0_CTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000088ull);
}
#else
#define CVMX_DFA_PFC0_CTL (CVMX_ADD_IO_SEG(0x0001180037000088ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC1_CNT CVMX_DFA_PFC1_CNT_FUNC()
static inline uint64_t CVMX_DFA_PFC1_CNT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC1_CNT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370000A0ull);
}
#else
#define CVMX_DFA_PFC1_CNT (CVMX_ADD_IO_SEG(0x00011800370000A0ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC1_CTL CVMX_DFA_PFC1_CTL_FUNC()
static inline uint64_t CVMX_DFA_PFC1_CTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC1_CTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000098ull);
}
#else
#define CVMX_DFA_PFC1_CTL (CVMX_ADD_IO_SEG(0x0001180037000098ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC2_CNT CVMX_DFA_PFC2_CNT_FUNC()
static inline uint64_t CVMX_DFA_PFC2_CNT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC2_CNT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370000B0ull);
}
#else
#define CVMX_DFA_PFC2_CNT (CVMX_ADD_IO_SEG(0x00011800370000B0ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC2_CTL CVMX_DFA_PFC2_CTL_FUNC()
static inline uint64_t CVMX_DFA_PFC2_CTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC2_CTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370000A8ull);
}
#else
#define CVMX_DFA_PFC2_CTL (CVMX_ADD_IO_SEG(0x00011800370000A8ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC3_CNT CVMX_DFA_PFC3_CNT_FUNC()
static inline uint64_t CVMX_DFA_PFC3_CNT_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC3_CNT not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370000C0ull);
}
#else
#define CVMX_DFA_PFC3_CNT (CVMX_ADD_IO_SEG(0x00011800370000C0ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC3_CTL CVMX_DFA_PFC3_CTL_FUNC()
static inline uint64_t CVMX_DFA_PFC3_CTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC3_CTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x00011800370000B8ull);
}
#else
#define CVMX_DFA_PFC3_CTL (CVMX_ADD_IO_SEG(0x00011800370000B8ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_PFC_GCTL CVMX_DFA_PFC_GCTL_FUNC()
static inline uint64_t CVMX_DFA_PFC_GCTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN63XX)))
		cvmx_warn("CVMX_DFA_PFC_GCTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180037000080ull);
}
#else
#define CVMX_DFA_PFC_GCTL (CVMX_ADD_IO_SEG(0x0001180037000080ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_RODT_COMP_CTL CVMX_DFA_RODT_COMP_CTL_FUNC()
static inline uint64_t CVMX_DFA_RODT_COMP_CTL_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_RODT_COMP_CTL not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000068ull);
}
#else
#define CVMX_DFA_RODT_COMP_CTL (CVMX_ADD_IO_SEG(0x0001180030000068ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_SBD_DBG0 CVMX_DFA_SBD_DBG0_FUNC()
static inline uint64_t CVMX_DFA_SBD_DBG0_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_SBD_DBG0 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000040ull);
}
#else
#define CVMX_DFA_SBD_DBG0 (CVMX_ADD_IO_SEG(0x0001180030000040ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_SBD_DBG1 CVMX_DFA_SBD_DBG1_FUNC()
static inline uint64_t CVMX_DFA_SBD_DBG1_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_SBD_DBG1 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000048ull);
}
#else
#define CVMX_DFA_SBD_DBG1 (CVMX_ADD_IO_SEG(0x0001180030000048ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_SBD_DBG2 CVMX_DFA_SBD_DBG2_FUNC()
static inline uint64_t CVMX_DFA_SBD_DBG2_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_SBD_DBG2 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000050ull);
}
#else
#define CVMX_DFA_SBD_DBG2 (CVMX_ADD_IO_SEG(0x0001180030000050ull))
#endif
#if CVMX_ENABLE_CSR_ADDRESS_CHECKING
#define CVMX_DFA_SBD_DBG3 CVMX_DFA_SBD_DBG3_FUNC()
static inline uint64_t CVMX_DFA_SBD_DBG3_FUNC(void)
{
	if (!(OCTEON_IS_MODEL(OCTEON_CN31XX) || OCTEON_IS_MODEL(OCTEON_CN38XX) || OCTEON_IS_MODEL(OCTEON_CN58XX)))
		cvmx_warn("CVMX_DFA_SBD_DBG3 not supported on this chip\n");
	return CVMX_ADD_IO_SEG(0x0001180030000058ull);
}
#else
#define CVMX_DFA_SBD_DBG3 (CVMX_ADD_IO_SEG(0x0001180030000058ull))
#endif

/**
 * cvmx_dfa_bist0
 *
 * DFA_BIST0 = DFA Bist Status (per-DTC)
 *
 * Description:
 */
union cvmx_dfa_bist0
{
	uint64_t u64;
	struct cvmx_dfa_bist0_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_29_63               : 35;
	uint64_t mwb                          : 1;  /**< Bist Results for MWB RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_25_27               : 3;
	uint64_t gfb                          : 1;  /**< Bist Results for GFB RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_18_23               : 6;
	uint64_t stx                          : 2;  /**< Bist Results for STX RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_10_15               : 6;
	uint64_t dtx                          : 2;  /**< Bist Results for DTX RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_5_7                 : 3;
	uint64_t rdf                          : 1;  /**< Bist Results for RWB[3:0] RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_1_3                 : 3;
	uint64_t pdb                          : 1;  /**< Bist Results for PDB RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
#else
	uint64_t pdb                          : 1;
	uint64_t reserved_1_3                 : 3;
	uint64_t rdf                          : 1;
	uint64_t reserved_5_7                 : 3;
	uint64_t dtx                          : 2;
	uint64_t reserved_10_15               : 6;
	uint64_t stx                          : 2;
	uint64_t reserved_18_23               : 6;
	uint64_t gfb                          : 1;
	uint64_t reserved_25_27               : 3;
	uint64_t mwb                          : 1;
	uint64_t reserved_29_63               : 35;
#endif
	} s;
	struct cvmx_dfa_bist0_s               cn63xx;
	struct cvmx_dfa_bist0_s               cn63xxp1;
};
typedef union cvmx_dfa_bist0 cvmx_dfa_bist0_t;

/**
 * cvmx_dfa_bist1
 *
 * DFA_BIST1 = DFA Bist Status (Globals)
 *
 * Description:
 */
union cvmx_dfa_bist1
{
	uint64_t u64;
	struct cvmx_dfa_bist1_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_13_63               : 51;
	uint64_t ram3                         : 1;  /**< Bist Results for RAM3 RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t ram2                         : 1;  /**< Bist Results for RAM2 RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t ram1                         : 1;  /**< Bist Results for RAM1 RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t crq                          : 1;  /**< Bist Results for CRQ RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gutv                         : 1;  /**< Bist Results for GUTV RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_5_7                 : 3;
	uint64_t gutp                         : 1;  /**< Bist Results for NCD RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t ncd                          : 1;  /**< Bist Results for NCD RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gif                          : 1;  /**< Bist Results for GIF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gib                          : 1;  /**< Bist Results for GIB RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gfu                          : 1;  /**< Bist Results for GFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
#else
	uint64_t gfu                          : 1;
	uint64_t gib                          : 1;
	uint64_t gif                          : 1;
	uint64_t ncd                          : 1;
	uint64_t gutp                         : 1;
	uint64_t reserved_5_7                 : 3;
	uint64_t gutv                         : 1;
	uint64_t crq                          : 1;
	uint64_t ram1                         : 1;
	uint64_t ram2                         : 1;
	uint64_t ram3                         : 1;
	uint64_t reserved_13_63               : 51;
#endif
	} s;
	struct cvmx_dfa_bist1_s               cn63xx;
	struct cvmx_dfa_bist1_s               cn63xxp1;
};
typedef union cvmx_dfa_bist1 cvmx_dfa_bist1_t;

/**
 * cvmx_dfa_bst0
 *
 * DFA_BST0 = DFA Bist Status
 *
 * Description:
 */
union cvmx_dfa_bst0
{
	uint64_t u64;
	struct cvmx_dfa_bst0_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_32_63               : 32;
	uint64_t rdf                          : 16; /**< Bist Results for RDF[3:0] RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t pdf                          : 16; /**< Bist Results for PDF[3:0] RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
#else
	uint64_t pdf                          : 16;
	uint64_t rdf                          : 16;
	uint64_t reserved_32_63               : 32;
#endif
	} s;
	struct cvmx_dfa_bst0_s                cn31xx;
	struct cvmx_dfa_bst0_s                cn38xx;
	struct cvmx_dfa_bst0_s                cn38xxp2;
	struct cvmx_dfa_bst0_cn58xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_20_63               : 44;
	uint64_t rdf                          : 4;  /**< Bist Results for RDF[3:0] RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_4_15                : 12;
	uint64_t pdf                          : 4;  /**< Bist Results for PDF[3:0] RAM(s)
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
#else
	uint64_t pdf                          : 4;
	uint64_t reserved_4_15                : 12;
	uint64_t rdf                          : 4;
	uint64_t reserved_20_63               : 44;
#endif
	} cn58xx;
	struct cvmx_dfa_bst0_cn58xx           cn58xxp1;
};
typedef union cvmx_dfa_bst0 cvmx_dfa_bst0_t;

/**
 * cvmx_dfa_bst1
 *
 * DFA_BST1 = DFA Bist Status
 *
 * Description:
 */
union cvmx_dfa_bst1
{
	uint64_t u64;
	struct cvmx_dfa_bst1_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_23_63               : 41;
	uint64_t crq                          : 1;  /**< Bist Results for CRQ RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t ifu                          : 1;  /**< Bist Results for IFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gfu                          : 1;  /**< Bist Results for GFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t drf                          : 1;  /**< Bist Results for DRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t crf                          : 1;  /**< Bist Results for CRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p0_bwb                       : 1;  /**< Bist Results for P0_BWB RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p1_bwb                       : 1;  /**< Bist Results for P1_BWB RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p0_brf                       : 8;  /**< Bist Results for P0_BRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p1_brf                       : 8;  /**< Bist Results for P1_BRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
#else
	uint64_t p1_brf                       : 8;
	uint64_t p0_brf                       : 8;
	uint64_t p1_bwb                       : 1;
	uint64_t p0_bwb                       : 1;
	uint64_t crf                          : 1;
	uint64_t drf                          : 1;
	uint64_t gfu                          : 1;
	uint64_t ifu                          : 1;
	uint64_t crq                          : 1;
	uint64_t reserved_23_63               : 41;
#endif
	} s;
	struct cvmx_dfa_bst1_cn31xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_23_63               : 41;
	uint64_t crq                          : 1;  /**< Bist Results for CRQ RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t ifu                          : 1;  /**< Bist Results for IFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gfu                          : 1;  /**< Bist Results for GFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t drf                          : 1;  /**< Bist Results for DRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t crf                          : 1;  /**< Bist Results for CRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_0_17                : 18;
#else
	uint64_t reserved_0_17                : 18;
	uint64_t crf                          : 1;
	uint64_t drf                          : 1;
	uint64_t gfu                          : 1;
	uint64_t ifu                          : 1;
	uint64_t crq                          : 1;
	uint64_t reserved_23_63               : 41;
#endif
	} cn31xx;
	struct cvmx_dfa_bst1_s                cn38xx;
	struct cvmx_dfa_bst1_s                cn38xxp2;
	struct cvmx_dfa_bst1_cn58xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_23_63               : 41;
	uint64_t crq                          : 1;  /**< Bist Results for CRQ RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t ifu                          : 1;  /**< Bist Results for IFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t gfu                          : 1;  /**< Bist Results for GFU RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t reserved_19_19               : 1;
	uint64_t crf                          : 1;  /**< Bist Results for CRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p0_bwb                       : 1;  /**< Bist Results for P0_BWB RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p1_bwb                       : 1;  /**< Bist Results for P1_BWB RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p0_brf                       : 8;  /**< Bist Results for P0_BRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
	uint64_t p1_brf                       : 8;  /**< Bist Results for P1_BRF RAM
                                                         - 0: GOOD (or bist in progress/never run)
                                                         - 1: BAD */
#else
	uint64_t p1_brf                       : 8;
	uint64_t p0_brf                       : 8;
	uint64_t p1_bwb                       : 1;
	uint64_t p0_bwb                       : 1;
	uint64_t crf                          : 1;
	uint64_t reserved_19_19               : 1;
	uint64_t gfu                          : 1;
	uint64_t ifu                          : 1;
	uint64_t crq                          : 1;
	uint64_t reserved_23_63               : 41;
#endif
	} cn58xx;
	struct cvmx_dfa_bst1_cn58xx           cn58xxp1;
};
typedef union cvmx_dfa_bst1 cvmx_dfa_bst1_t;

/**
 * cvmx_dfa_cfg
 *
 * Specify the RSL base addresses for the block
 *
 *                  DFA_CFG = DFA Configuration
 *
 * Description:
 */
union cvmx_dfa_cfg
{
	uint64_t u64;
	struct cvmx_dfa_cfg_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_4_63                : 60;
	uint64_t nrpl_ena                     : 1;  /**< When set, allows the per-node replication feature to be
                                                         enabled.
                                                         In 36-bit mode: The IWORD0[31:30]=SNREPL field AND
                                                         bits [21:20] of the Next Node ptr are used in generating
                                                         the next node address (see OCTEON HRM - DFA Chapter for
                                                         psuedo-code of DTE next node address generation).
                                                         NOTE: When NRPL_ENA=1 and IWORD0[TY]=1(36b mode),
                                                         (regardless of IWORD0[NRPLEN]), the Resultant Word1+
                                                         [[47:44],[23:20]] = Next Node's [27:20] bits. This allows
                                                         SW to use the RESERVED bits of the final node for SW
                                                         caching. Also, if required, SW will use [22:21]=Node
                                                         Replication to re-start the same graph walk(if graph
                                                         walk prematurely terminated (ie: DATA_GONE).
                                                         In 18-bit mode: The IWORD0[31:30]=SNREPL field AND
                                                         bit [16:14] of the Next Node ptr are used in generating
                                                         the next node address (see OCTEON HRM - DFA Chapter for
                                                         psuedo-code of DTE next node address generation).
                                                         If (IWORD0[NREPLEN]=1 and DFA_CFG[NRPL_ENA]=1) [
                                                            If next node ptr[16] is set [
                                                              next node ptr[15:14] indicates the next node repl
                                                              next node ptr[13:0]  indicates the position of the
                                                                 node relative to the first normal node (i.e.
                                                                 IWORD3[Msize] must be added to get the final node)
                                                            ]
                                                            else If next node ptr[16] is not set [
                                                              next node ptr[15:0] indicates the next node id
                                                              next node repl = 0
                                                            ]
                                                         ]
                                                         NOTE: For 18b node replication, MAX node space=64KB(2^16)
                                                         is used in detecting terminal node space(see HRM for full
                                                         description).
                                                         NOTE: The DFA graphs MUST BE built/written to DFA LLM memory
                                                         aware of the "per-node" replication. */
	uint64_t nxor_ena                     : 1;  /**< When set, allows the DTE Instruction IWORD0[NXOREN]
                                                         to be used to enable/disable the per-node address 'scramble'
                                                         of the LLM address to lessen the effects of bank conflicts.
                                                         If IWORD0[NXOREN] is also set, then:
                                                         In 36-bit mode: The node_Id[7:0] 8-bit value is XORed
                                                         against the LLM address addr[9:2].
                                                         In 18-bit mode: The node_id[6:0] 7-bit value is XORed
                                                         against the LLM address addr[8:2]. (note: we don't address
                                                         scramble outside the mode's node space).
                                                         NOTE: The DFA graphs MUST BE built/written to DFA LLM memory
                                                         aware of the "per-node" address scramble.
                                                         NOTE: The address 'scramble' ocurs for BOTH DFA LLM graph
                                                         read/write operations. */
	uint64_t gxor_ena                     : 1;  /**< When set, the DTE Instruction IWORD0[GXOR]
                                                         field is used to 'scramble' the LLM address
                                                         to lessen the effects of bank conflicts.
                                                         In 36-bit mode: The GXOR[7:0] 8-bit value is XORed
                                                         against the LLM address addr[9:2].
                                                         In 18-bit mode: GXOR[6:0] 7-bit value is XORed against
                                                         the LLM address addr[8:2]. (note: we don't address
                                                         scramble outside the mode's node space)
                                                         NOTE: The DFA graphs MUST BE built/written to DFA LLM memory
                                                         aware of the "per-graph" address scramble.
                                                         NOTE: The address 'scramble' ocurs for BOTH DFA LLM graph
                                                         read/write operations. */
	uint64_t sarb                         : 1;  /**< DFA Source Arbiter Mode
                                                         Selects the arbitration mode used to select DFA
                                                         requests issued from either CP2 or the DTE (NCB-CSR
                                                         or DFA HW engine).
                                                            - 0: Fixed Priority [Highest=CP2, Lowest=DTE]
                                                            - 1: Round-Robin
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
#else
	uint64_t sarb                         : 1;
	uint64_t gxor_ena                     : 1;
	uint64_t nxor_ena                     : 1;
	uint64_t nrpl_ena                     : 1;
	uint64_t reserved_4_63                : 60;
#endif
	} s;
	struct cvmx_dfa_cfg_s                 cn38xx;
	struct cvmx_dfa_cfg_cn38xxp2
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_1_63                : 63;
	uint64_t sarb                         : 1;  /**< DFA Source Arbiter Mode
                                                         Selects the arbitration mode used to select DFA
                                                         requests issued from either CP2 or the DTE (NCB-CSR
                                                         or DFA HW engine).
                                                            - 0: Fixed Priority [Highest=CP2, Lowest=DTE]
                                                            - 1: Round-Robin
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
#else
	uint64_t sarb                         : 1;
	uint64_t reserved_1_63                : 63;
#endif
	} cn38xxp2;
	struct cvmx_dfa_cfg_s                 cn58xx;
	struct cvmx_dfa_cfg_s                 cn58xxp1;
};
typedef union cvmx_dfa_cfg cvmx_dfa_cfg_t;

/**
 * cvmx_dfa_config
 *
 * Specify the RSL base addresses for the block
 *
 *                  DFA_CONFIG = DFA Configuration Register
 *
 * Description:
 */
union cvmx_dfa_config
{
	uint64_t u64;
	struct cvmx_dfa_config_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_9_63                : 55;
	uint64_t repl_ena                     : 1;  /**< Replication Mode Enable
                                                         *** o63-P2 NEW ***
                                                         When set, enables replication mode performance enhancement
                                                         feature. This enables the DFA to communicate address
                                                         replication information during memory references to the DFM
                                                         (memory controller). This in turn is used by the DFM to support
                                                         graph data in multiple banks (or bank sets), so that the least
                                                         full bank can be selected to minimize the effects of DDR3 bank
                                                         conflicts (ie: tRC=row cycle time).
                                                         SWNOTE: Using this mode requires the DFA SW compiler and DFA
                                                         driver to be aware of the o63-P2 address replication changes.
                                                         This involves changes to the MLOAD/GWALK DFA instruction format
                                                         (see: IWORD2.SREPL), as well as changes to node arc and metadata
                                                         definitions which now support an additional REPL field.
                                                         When clear, replication mode is disabled, and DFA will interpret
                                                         o63-P1 DFA instructions and node-arc formats which DO NOT have
                                                         address replication information. */
	uint64_t clmskcrip                    : 4;  /**< Cluster Cripple Mask
                                                         A one in each bit of the mask represents which DTE cluster to
                                                         cripple.
                                                         NOTE: o63 has only a single Cluster (therefore CLMSKCRIP[0]
                                                         is the only bit used.
                                                         o2 has 4 clusters, where all CLMSKCRIP mask bits are used.
                                                         SWNOTE: The MIO_FUS___DFA_CLMASK_CRIPPLE[3:0] fuse bits will
                                                         be forced into this register at reset. Any fuse bits that
                                                         contain '1' will be disallowed during a write and will always
                                                         be read as '1'. */
	uint64_t cldtecrip                    : 3;  /**< Encoding which represents \#of DTEs to cripple for each
                                                         cluster. Typically DTE_CLCRIP=0 which enables all DTEs
                                                         within each cluster. However, when the DFA performance
                                                         counters are used, SW may want to limit the \#of DTEs
                                                         per cluster available, as there are only 4 parallel
                                                         performance counters.
                                                            DTE_CLCRIP | \#DTEs crippled(per cluster)
                                                         ------------+-----------------------------
                                                                0    |  0      DTE[15:0]:ON
                                                                1    |  1/2    DTE[15:8]:OFF  /DTE[7:0]:ON
                                                                2    |  1/4    DTE[15:12]:OFF /DTE[11:0]:ON
                                                                3    |  3/4    DTE[15:4]:OFF  /DTE[3:0]:ON
                                                                4    |  1/8    DTE[15:14]:OFF /DTE[13:0]:ON
                                                                5    |  5/8    DTE[15:6]:OFF  /DTE[5:0]:ON
                                                                6    |  3/8    DTE[15:10]:OFF /DTE[9:0]:ON
                                                                7    |  7/8    DTE[15:2]:OFF  /DTE[1:0]:ON
                                                         NOTE: Higher numbered DTEs are crippled first. For instance,
                                                         on o63 (with 16 DTEs/cluster), if DTE_CLCRIP=1(1/2), then
                                                         DTE#s [15:8] within the cluster are crippled and only
                                                         DTE#s [7:0] are available.
                                                         IMPNOTE: The encodings are done in such a way as to later
                                                         be used with fuses (for future o2 revisions which will disable
                                                         some \#of DTEs). Blowing a fuse has the effect that there will
                                                         always be fewer DTEs available. [ie: we never want a customer
                                                         to blow additional fuses to get more DTEs].
                                                         SWNOTE: The MIO_FUS___DFA_NUMDTE_CRIPPLE[2:0] fuse bits will
                                                         be forced into this register at reset. Any fuse bits that
                                                         contain '1' will be disallowed during a write and will always
                                                         be read as '1'. */
	uint64_t dteclkdis                    : 1;  /**< DFA Clock Disable Source
                                                         When SET, the DFA clocks for DTE(thread engine)
                                                         operation are disabled (to conserve overall chip clocking
                                                         power when the DFA function is not used).
                                                         NOTE: When SET, SW MUST NEVER issue NCB-Direct CSR
                                                         operations to the DFA (will result in NCB Bus Timeout
                                                         errors).
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         SWNOTE: The MIO_FUS___DFA_DTE_DISABLE fuse bit will
                                                         be forced into this register at reset. If the fuse bit
                                                         contains '1', writes to DTECLKDIS are disallowed and
                                                         will always be read as '1'. */
#else
	uint64_t dteclkdis                    : 1;
	uint64_t cldtecrip                    : 3;
	uint64_t clmskcrip                    : 4;
	uint64_t repl_ena                     : 1;
	uint64_t reserved_9_63                : 55;
#endif
	} s;
	struct cvmx_dfa_config_s              cn63xx;
	struct cvmx_dfa_config_cn63xxp1
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_8_63                : 56;
	uint64_t clmskcrip                    : 4;  /**< Cluster Cripple Mask
                                                         A one in each bit of the mask represents which DTE cluster to
                                                         cripple.
                                                         NOTE: o63 has only a single Cluster (therefore CLMSKCRIP[0]
                                                         is the only bit used.
                                                         o2 has 4 clusters, where all CLMSKCRIP mask bits are used.
                                                         SWNOTE: The MIO_FUS___DFA_CLMASK_CRIPPLE[3:0] fuse bits will
                                                         be forced into this register at reset. Any fuse bits that
                                                         contain '1' will be disallowed during a write and will always
                                                         be read as '1'. */
	uint64_t cldtecrip                    : 3;  /**< Encoding which represents \#of DTEs to cripple for each
                                                         cluster. Typically DTE_CLCRIP=0 which enables all DTEs
                                                         within each cluster. However, when the DFA performance
                                                         counters are used, SW may want to limit the \#of DTEs
                                                         per cluster available, as there are only 4 parallel
                                                         performance counters.
                                                            DTE_CLCRIP | \#DTEs crippled(per cluster)
                                                         ------------+-----------------------------
                                                                0    |  0      DTE[15:0]:ON
                                                                1    |  1/2    DTE[15:8]:OFF  /DTE[7:0]:ON
                                                                2    |  1/4    DTE[15:12]:OFF /DTE[11:0]:ON
                                                                3    |  3/4    DTE[15:4]:OFF  /DTE[3:0]:ON
                                                                4    |  1/8    DTE[15:14]:OFF /DTE[13:0]:ON
                                                                5    |  5/8    DTE[15:6]:OFF  /DTE[5:0]:ON
                                                                6    |  3/8    DTE[15:10]:OFF /DTE[9:0]:ON
                                                                7    |  7/8    DTE[15:2]:OFF  /DTE[1:0]:ON
                                                         NOTE: Higher numbered DTEs are crippled first. For instance,
                                                         on o63 (with 16 DTEs/cluster), if DTE_CLCRIP=1(1/2), then
                                                         DTE#s [15:8] within the cluster are crippled and only
                                                         DTE#s [7:0] are available.
                                                         IMPNOTE: The encodings are done in such a way as to later
                                                         be used with fuses (for future o2 revisions which will disable
                                                         some \#of DTEs). Blowing a fuse has the effect that there will
                                                         always be fewer DTEs available. [ie: we never want a customer
                                                         to blow additional fuses to get more DTEs].
                                                         SWNOTE: The MIO_FUS___DFA_NUMDTE_CRIPPLE[2:0] fuse bits will
                                                         be forced into this register at reset. Any fuse bits that
                                                         contain '1' will be disallowed during a write and will always
                                                         be read as '1'. */
	uint64_t dteclkdis                    : 1;  /**< DFA Clock Disable Source
                                                         When SET, the DFA clocks for DTE(thread engine)
                                                         operation are disabled (to conserve overall chip clocking
                                                         power when the DFA function is not used).
                                                         NOTE: When SET, SW MUST NEVER issue NCB-Direct CSR
                                                         operations to the DFA (will result in NCB Bus Timeout
                                                         errors).
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         SWNOTE: The MIO_FUS___DFA_DTE_DISABLE fuse bit will
                                                         be forced into this register at reset. If the fuse bit
                                                         contains '1', writes to DTECLKDIS are disallowed and
                                                         will always be read as '1'. */
#else
	uint64_t dteclkdis                    : 1;
	uint64_t cldtecrip                    : 3;
	uint64_t clmskcrip                    : 4;
	uint64_t reserved_8_63                : 56;
#endif
	} cn63xxp1;
};
typedef union cvmx_dfa_config cvmx_dfa_config_t;

/**
 * cvmx_dfa_control
 *
 * DFA_CONTROL = DFA Control Register
 *
 * Description:
 */
union cvmx_dfa_control
{
	uint64_t u64;
	struct cvmx_dfa_control_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_10_63               : 54;
	uint64_t sbdnum                       : 4;  /**< SBD Debug Entry#
                                                         *FOR INTERNAL USE ONLY*
                                                         DFA Scoreboard debug control
                                                         Selects which one of 8 DFA Scoreboard entries is
                                                         latched into the DFA_SBD_DBG[0-3] registers. */
	uint64_t sbdlck                       : 1;  /**< DFA Scoreboard LOCK Strobe
                                                         *FOR INTERNAL USE ONLY*
                                                         DFA Scoreboard debug control
                                                         When written with a '1', the DFA Scoreboard Debug
                                                         registers (DFA_SBD_DBG[0-3]) are all locked down.
                                                         This allows SW to lock down the contents of the entire
                                                         SBD for a single instant in time. All subsequent reads
                                                         of the DFA scoreboard registers will return the data
                                                         from that instant in time. */
	uint64_t reserved_3_4                 : 2;
	uint64_t pmode                        : 1;  /**< NCB-NRP Arbiter Mode
                                                         (0=Fixed Priority [LP=WQF,DFF,HP=RGF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t qmode                        : 1;  /**< NCB-NRQ Arbiter Mode
                                                         (0=Fixed Priority [LP=IRF,RWF,PRF,HP=GRF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t imode                        : 1;  /**< NCB-Inbound Arbiter
                                                         (0=FP [LP=NRQ,HP=NRP], 1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
#else
	uint64_t imode                        : 1;
	uint64_t qmode                        : 1;
	uint64_t pmode                        : 1;
	uint64_t reserved_3_4                 : 2;
	uint64_t sbdlck                       : 1;
	uint64_t sbdnum                       : 4;
	uint64_t reserved_10_63               : 54;
#endif
	} s;
	struct cvmx_dfa_control_s             cn63xx;
	struct cvmx_dfa_control_s             cn63xxp1;
};
typedef union cvmx_dfa_control cvmx_dfa_control_t;

/**
 * cvmx_dfa_dbell
 *
 * DFA_DBELL = DFA Doorbell Register
 *
 * Description:
 *  NOTE: To write to the DFA_DBELL register, a device would issue an IOBST directed at the DFA with addr[34:33]=2'b00.
 *        To read the DFA_DBELL register, a device would issue an IOBLD64 directed at the DFA with addr[34:33]=2'b00.
 *
 *  NOTE: If DFA_CONFIG[DTECLKDIS]=1 (DFA-DTE clocks disabled), reads/writes to the DFA_DBELL register do not take effect.
 *  NOTE: If FUSE[TBD]="DFA DTE disable" is blown, reads/writes to the DFA_DBELL register do not take effect.
 */
union cvmx_dfa_dbell
{
	uint64_t u64;
	struct cvmx_dfa_dbell_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_20_63               : 44;
	uint64_t dbell                        : 20; /**< Represents the cumulative total of pending
                                                         DFA instructions which SW has previously written
                                                         into the DFA Instruction FIFO (DIF) in main memory.
                                                         Each DFA instruction contains a fixed size 32B
                                                         instruction word which is executed by the DFA HW.
                                                         The DBL register can hold up to 1M-1 (2^20-1)
                                                         pending DFA instruction requests.
                                                         During a read (by SW), the 'most recent' contents
                                                         of the DFA_DBELL register are returned at the time
                                                         the NCB-INB bus is driven.
                                                         NOTE: Since DFA HW updates this register, its
                                                         contents are unpredictable in SW. */
#else
	uint64_t dbell                        : 20;
	uint64_t reserved_20_63               : 44;
#endif
	} s;
	struct cvmx_dfa_dbell_s               cn31xx;
	struct cvmx_dfa_dbell_s               cn38xx;
	struct cvmx_dfa_dbell_s               cn38xxp2;
	struct cvmx_dfa_dbell_s               cn58xx;
	struct cvmx_dfa_dbell_s               cn58xxp1;
	struct cvmx_dfa_dbell_s               cn63xx;
	struct cvmx_dfa_dbell_s               cn63xxp1;
};
typedef union cvmx_dfa_dbell cvmx_dfa_dbell_t;

/**
 * cvmx_dfa_ddr2_addr
 *
 * DFA_DDR2_ADDR = DFA DDR2  fclk-domain Memory Address Config Register
 *
 *
 * Description: The following registers are used to compose the DFA's DDR2 address into ROW/COL/BNK
 *              etc.
 */
union cvmx_dfa_ddr2_addr
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_addr_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_9_63                : 55;
	uint64_t rdimm_ena                    : 1;  /**< If there is a need to insert a register chip on the
                                                         system (the equivalent of a registered DIMM) to
                                                         provide better setup for the command and control bits
                                                         turn this mode on.
                                                             RDIMM_ENA
                                                                0           Registered Mode OFF
                                                                1           Registered Mode ON */
	uint64_t num_rnks                     : 2;  /**< NUM_RNKS is programmed based on how many ranks there
                                                         are in the system. This needs to be programmed correctly
                                                         regardless of whether we are in RNK_LO mode or not.
                                                            NUM_RNKS     \# of Ranks
                                                              0              1
                                                              1              2
                                                              2              4
                                                              3              RESERVED */
	uint64_t rnk_lo                       : 1;  /**< When this mode is turned on, consecutive addresses
                                                         outside the bank boundary
                                                         are programmed to go to different ranks in order to
                                                         minimize bank conflicts. It is useful in 4-bank DDR2
                                                         parts based memory to extend out the \#physical banks
                                                         available and minimize bank conflicts.
                                                         On 8 bank ddr2 parts, this mode is not very useful
                                                         because this mode does come with
                                                         a penalty which is that every successive reads that
                                                         cross rank boundary will need a 1 cycle bubble
                                                         inserted to prevent bus turnaround conflicts.
                                                            RNK_LO
                                                             0      - OFF
                                                             1      - ON */
	uint64_t num_colrows                  : 3;  /**< NUM_COLROWS    is used to set the MSB of the ROW_ADDR
                                                         and the LSB of RANK address when not in RNK_LO mode.
                                                         Calculate the sum of \#COL and \#ROW and program the
                                                         controller appropriately
                                                            RANK_LSB        \#COLs + \#ROWs
                                                            ------------------------------
                                                             - 000:                   22
                                                             - 001:                   23
                                                             - 010:                   24
                                                             - 011:                   25
                                                            - 100-111:             RESERVED */
	uint64_t num_cols                     : 2;  /**< The Long word address that the controller receives
                                                         needs to be converted to Row, Col, Rank and Bank
                                                         addresses depending on the memory part's micro arch.
                                                         NUM_COL tells the controller how many colum bits
                                                         there are and the controller uses this info to map
                                                         the LSB of the row address
                                                             - 00: num_cols = 9
                                                             - 01: num_cols = 10
                                                             - 10: num_cols = 11
                                                             - 11: RESERVED */
#else
	uint64_t num_cols                     : 2;
	uint64_t num_colrows                  : 3;
	uint64_t rnk_lo                       : 1;
	uint64_t num_rnks                     : 2;
	uint64_t rdimm_ena                    : 1;
	uint64_t reserved_9_63                : 55;
#endif
	} s;
	struct cvmx_dfa_ddr2_addr_s           cn31xx;
};
typedef union cvmx_dfa_ddr2_addr cvmx_dfa_ddr2_addr_t;

/**
 * cvmx_dfa_ddr2_bus
 *
 * DFA_DDR2_BUS = DFA DDR Bus Activity Counter
 *
 *
 * Description: This counter counts \# cycles that the memory bus is doing a read/write/command
 *              Useful to benchmark the bus utilization as a ratio of
 *              \#Cycles of Data Transfer/\#Cycles since init or
 *              \#Cycles of Data Transfer/\#Cycles that memory controller is active
 */
union cvmx_dfa_ddr2_bus
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_bus_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_47_63               : 17;
	uint64_t bus_cnt                      : 47; /**< Counter counts the \# cycles of Data transfer */
#else
	uint64_t bus_cnt                      : 47;
	uint64_t reserved_47_63               : 17;
#endif
	} s;
	struct cvmx_dfa_ddr2_bus_s            cn31xx;
};
typedef union cvmx_dfa_ddr2_bus cvmx_dfa_ddr2_bus_t;

/**
 * cvmx_dfa_ddr2_cfg
 *
 * DFA_DDR2_CFG = DFA DDR2 fclk-domain Memory Configuration \#0 Register
 *
 * Description:
 */
union cvmx_dfa_ddr2_cfg
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_cfg_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_41_63               : 23;
	uint64_t trfc                         : 5;  /**< Establishes tRFC(from DDR2 data sheets) in \# of
                                                         4 fclk intervals.
                                                         General Equation:
                                                         TRFC(csr) = ROUNDUP[tRFC(data-sheet-ns)/(4 * fclk(ns))]
                                                         Example:
                                                            tRFC(data-sheet-ns) = 127.5ns
                                                            Operational Frequency: 533MHz DDR rate
                                                                [fclk=266MHz(3.75ns)]
                                                         Then:
                                                            TRFC(csr) = ROUNDUP[127.5ns/(4 * 3.75ns)]
                                                                      = 9 */
	uint64_t mrs_pgm                      : 1;  /**< When clear, the HW initialization sequence fixes
                                                         some of the *MRS register bit definitions.
                                                            EMRS:
                                                              A[14:13] = 0 RESERVED
                                                              A[12] = 0    Output Buffers Enabled (FIXED)
                                                              A[11] = 0    RDQS Disabled (FIXED)
                                                              A[10] = 0    DQSn Enabled (FIXED)
                                                              A[9:7] = 0   OCD Not supported (FIXED)
                                                              A[6] = 0     RTT Disabled (FIXED)
                                                              A[5:3]=DFA_DDR2_TMG[ADDLAT] (if DFA_DDR2_TMG[POCAS]=1)
                                                                            Additive LATENCY (Programmable)
                                                              A[2]=0       RTT Disabled (FIXED)
                                                              A[1]=DFA_DDR2_TMG[DIC] (Programmable)
                                                              A[0] = 0     DLL Enabled (FIXED)
                                                            MRS:
                                                              A[14:13] = 0 RESERVED
                                                              A[12] = 0    Fast Active Power Down Mode (FIXED)
                                                              A[11:9] = DFA_DDR2_TMG[TWR](Programmable)
                                                              A[8] = 1     DLL Reset (FIXED)
                                                              A[7] = 0     Test Mode (FIXED)
                                                              A[6:4]=DFA_DDR2_TMG[CASLAT] CAS LATENCY (Programmable)
                                                              A[3] = 0     Burst Type(must be 0:Sequential) (FIXED)
                                                              A[2:0] = 2   Burst Length=4 (must be 0:Sequential) (FIXED)
                                                         When set, the HW initialization sequence sources
                                                         the DFA_DDR2_MRS, DFA_DDR2_EMRS registers which are
                                                         driven onto the DFA_A[] pins. (this allows the MRS/EMRS
                                                         fields to be completely programmable - however care
                                                         must be taken by software).
                                                         This mode is useful for customers who wish to:
                                                            1) override the FIXED definitions(above), or
                                                            2) Use a "clamshell mode" of operation where the
                                                               address bits(per rank) are swizzled on the
                                                               board to reduce stub lengths for optimal
                                                               frequency operation.
                                                         Use this in combination with DFA_DDR2_CFG[RNK_MSK]
                                                         to specify the INIT sequence for each of the 4
                                                         supported ranks. */
	uint64_t fpip                         : 3;  /**< Early Fill Programmable Pipe [\#fclks]
                                                         This field dictates the \#fclks prior to the arrival
                                                         of fill data(in fclk domain), to start the 'early' fill
                                                         command pipe (in the eclk domain) so as to minimize the
                                                         overall fill latency.
                                                         The programmable early fill command signal is synchronized
                                                         into the eclk domain, where it is used to pull data out of
                                                         asynchronous RAM as fast as possible.
                                                         NOTE: A value of FPIP=0 is the 'safest' setting and will
                                                         result in the early fill command pipe starting in the
                                                         same cycle as the fill data.
                                                         General Equation: (for FPIP)
                                                             FPIP <= MIN[6, (ROUND_DOWN[6/EF_RATIO] + 1)]
                                                         where:
                                                           EF_RATIO = ECLK/FCLK Ratio [eclk(MHz)/fclk(MHz)]
                                                         Example: FCLK=200MHz/ECLK=600MHz
                                                            FPIP = MIN[6, (ROUND_DOWN[6/(600/200))] + 1)]
                                                            FPIP <= 3 */
	uint64_t reserved_29_31               : 3;
	uint64_t ref_int                      : 13; /**< Refresh Interval (represented in \#of fclk
                                                         increments).
                                                         Each refresh interval will generate a single
                                                         auto-refresh command sequence which implicitly targets
                                                         all banks within the device:
                                                         Example: For fclk=200MHz(5ns)/400MHz(DDR):
                                                           trefint(ns) = [tREFI(max)=3.9us = 3900ns [datasheet]
                                                           REF_INT = ROUND_DOWN[(trefint/fclk)]
                                                                   = ROUND_DOWN[(3900ns/5ns)]
                                                                   = 780 fclks (0x30c)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t reserved_14_15               : 2;
	uint64_t tskw                         : 2;  /**< Board Skew (represented in \#fclks)
                                                         Represents additional board skew of DQ/DQS.
                                                             - 00: board-skew = 0 fclk
                                                             - 01: board-skew = 1 fclk
                                                             - 10: board-skew = 2 fclk
                                                             - 11: board-skew = 3 fclk
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t rnk_msk                      : 4;  /**< Controls the CS_N[3:0] during a) a HW Initialization
                                                         sequence (triggered by DFA_DDR2_CFG[INIT]) or
                                                         b) during a normal refresh sequence. If
                                                         the RNK_MSK[x]=1, the corresponding CS_N[x] is driven.
                                                         NOTE: This is required for DRAM used in a
                                                         clamshell configuration, since the address lines
                                                         carry Mode Register write data that is unique
                                                         per rank(or clam). In a clamshell configuration,
                                                         the N3K DFA_A[x] pin may be tied into Clam#0's A[x]
                                                         and also into Clam#1's 'mirrored' address bit A[y]
                                                         (eg: Clam0 sees A[5] and Clam1 sees A[15]).
                                                         To support clamshell designs, SW must initiate
                                                         separate HW init sequences each unique rank address
                                                         mapping. Before each HW init sequence is triggered,
                                                         SW must preload the DFA_DDR2_MRS/EMRS registers with
                                                         the data that will be driven onto the A[14:0] wires
                                                         during the EMRS/MRS mode register write(s).
                                                         NOTE: After the final HW initialization sequence has
                                                         been triggered, SW must wait 64K eclks before writing
                                                         the RNK_MSK[3:0] field = 3'b1111 (so that CS_N[3:0]
                                                         is driven during refresh sequences in normal operation.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t silo_qc                      : 1;  /**< Enables Quarter Cycle move of the Rd sampling window */
	uint64_t silo_hc                      : 1;  /**< A combination of SILO_HC, SILO_QC and TSKW
                                                         specifies the positioning of the sampling strobe
                                                         when receiving read data back from DDR2. This is
                                                         done to offset any board trace induced delay on
                                                         the DQ and DQS which inherently makes these
                                                         asynchronous with respect to the internal clk of
                                                         controller. TSKW moves this sampling window by
                                                         integer cycles. SILO_QC and HC move this quarter
                                                         and half a cycle respectively. */
	uint64_t sil_lat                      : 2;  /**< Silo Latency (\#fclks): On reads, determines how many
                                                         additional fclks to wait (on top of CASLAT+1) before
                                                         pulling data out of the padring silos used for time
                                                         domain boundary crossing.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t bprch                        : 1;  /**< Tristate Enable (back porch) (\#fclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable back porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t fprch                        : 1;  /**< Tristate Enable (front porch) (\#fclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable front porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t init                         : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for the LLM Memory Port is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Enable memory port
                                                               a) PRTENA=1
                                                           2) Wait 200us (to ensure a stable clock
                                                              to the DDR2) - as per DDR2 spec.
                                                           3) Write a '1' to the INIT which
                                                              will initiate a hardware initialization
                                                              sequence.
                                                         NOTE: After writing a '1', SW must wait 64K eclk
                                                         cycles to ensure the HW init sequence has completed
                                                         before writing to ANY of the DFA_DDR2* registers.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t prtena                       : 1;  /**< Enable DFA Memory
                                                         When enabled, this bit lets N3K be the default
                                                         driver for DFA-LLM memory port. */
#else
	uint64_t prtena                       : 1;
	uint64_t init                         : 1;
	uint64_t fprch                        : 1;
	uint64_t bprch                        : 1;
	uint64_t sil_lat                      : 2;
	uint64_t silo_hc                      : 1;
	uint64_t silo_qc                      : 1;
	uint64_t rnk_msk                      : 4;
	uint64_t tskw                         : 2;
	uint64_t reserved_14_15               : 2;
	uint64_t ref_int                      : 13;
	uint64_t reserved_29_31               : 3;
	uint64_t fpip                         : 3;
	uint64_t mrs_pgm                      : 1;
	uint64_t trfc                         : 5;
	uint64_t reserved_41_63               : 23;
#endif
	} s;
	struct cvmx_dfa_ddr2_cfg_s            cn31xx;
};
typedef union cvmx_dfa_ddr2_cfg cvmx_dfa_ddr2_cfg_t;

/**
 * cvmx_dfa_ddr2_comp
 *
 * DFA_DDR2_COMP = DFA DDR2 I/O PVT Compensation Configuration
 *
 *
 * Description: The following are registers to program the DDR2 PLL and DLL
 */
union cvmx_dfa_ddr2_comp
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_comp_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t dfa__pctl                    : 4;  /**< DFA DDR pctl from compensation circuit
                                                         Internal DBG only */
	uint64_t dfa__nctl                    : 4;  /**< DFA DDR nctl from compensation circuit
                                                         Internal DBG only */
	uint64_t reserved_9_55                : 47;
	uint64_t pctl_csr                     : 4;  /**< Compensation control bits */
	uint64_t nctl_csr                     : 4;  /**< Compensation control bits */
	uint64_t comp_bypass                  : 1;  /**< Compensation Bypass */
#else
	uint64_t comp_bypass                  : 1;
	uint64_t nctl_csr                     : 4;
	uint64_t pctl_csr                     : 4;
	uint64_t reserved_9_55                : 47;
	uint64_t dfa__nctl                    : 4;
	uint64_t dfa__pctl                    : 4;
#endif
	} s;
	struct cvmx_dfa_ddr2_comp_s           cn31xx;
};
typedef union cvmx_dfa_ddr2_comp cvmx_dfa_ddr2_comp_t;

/**
 * cvmx_dfa_ddr2_emrs
 *
 * DFA_DDR2_EMRS = DDR2 EMRS Register(s) EMRS1[14:0], EMRS1_OCD[14:0]
 * Description: This register contains the data driven onto the Address[14:0] lines during  DDR INIT
 * To support Clamshelling (where N3K DFA_A[] pins are not 1:1 mapped to each clam(or rank), a HW init
 * sequence is allowed on a "per-rank" basis. Care must be taken in the values programmed into these
 * registers during the HW initialization sequence (see N3K specific restrictions in notes below).
 * DFA_DDR2_CFG[MRS_PGM] must be 1 to support this feature.
 *
 * Notes:
 * For DDR-II please consult your device's data sheet for further details:
 *
 */
union cvmx_dfa_ddr2_emrs
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_emrs_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_31_63               : 33;
	uint64_t emrs1_ocd                    : 15; /**< Memory Address[14:0] during "EMRS1 (OCD Calibration)"
                                                         step \#12a "EMRS OCD Default Command" A[9:7]=111
                                                         of DDR2 HW initialization sequence.
                                                         (See JEDEC DDR2 specification (JESD79-2):
                                                         Power Up and initialization sequence).
                                                            A[14:13] = 0, RESERVED
                                                            A[12] = 0, Output Buffers Enabled
                                                            A[11] = 0, RDQS Disabled (we do not support RDQS)
                                                            A[10] = 0, DQSn Enabled
                                                            A[9:7] = 7, OCD Calibration Mode Default
                                                            A[6] = 0, ODT Disabled
                                                            A[5:3]=DFA_DDR2_TMG[ADDLAT]  Additive LATENCY (Default 0)
                                                            A[2]=0    Termination Res RTT (ODT off Default)
                                                            [A6,A2] = 0 -> ODT Disabled
                                                                      1 -> 75 ohm; 2 -> 150 ohm; 3 - Reserved
                                                            A[1]=0  Normal Output Driver Imp mode
                                                                    (1 - weak ie., 60% of normal drive strength)
                                                            A[0] = 0 DLL Enabled */
	uint64_t reserved_15_15               : 1;
	uint64_t emrs1                        : 15; /**< Memory Address[14:0] during:
                                                           a) Step \#7 "EMRS1 to enable DLL (A[0]=0)"
                                                           b) Step \#12b "EMRS OCD Calibration Mode Exit"
                                                         steps of DDR2 HW initialization sequence.
                                                         (See JEDEC DDR2 specification (JESD79-2): Power Up and
                                                         initialization sequence).
                                                           A[14:13] = 0, RESERVED
                                                           A[12] = 0, Output Buffers Enabled
                                                           A[11] = 0, RDQS Disabled (we do not support RDQS)
                                                           A[10] = 0, DQSn Enabled
                                                           A[9:7] = 0, OCD Calibration Mode exit/maintain
                                                           A[6] = 0, ODT Disabled
                                                           A[5:3]=DFA_DDR2_TMG[ADDLAT]  Additive LATENCY (Default 0)
                                                           A[2]=0    Termination Res RTT (ODT off Default)
                                                           [A6,A2] = 0 -> ODT Disabled
                                                                     1 -> 75 ohm; 2 -> 150 ohm; 3 - Reserved
                                                           A[1]=0  Normal Output Driver Imp mode
                                                                   (1 - weak ie., 60% of normal drive strength)
                                                           A[0] = 0 DLL Enabled */
#else
	uint64_t emrs1                        : 15;
	uint64_t reserved_15_15               : 1;
	uint64_t emrs1_ocd                    : 15;
	uint64_t reserved_31_63               : 33;
#endif
	} s;
	struct cvmx_dfa_ddr2_emrs_s           cn31xx;
};
typedef union cvmx_dfa_ddr2_emrs cvmx_dfa_ddr2_emrs_t;

/**
 * cvmx_dfa_ddr2_fcnt
 *
 * DFA_DDR2_FCNT = DFA FCLK Counter
 *
 *
 * Description: This FCLK cycle counter gets going after memory has been initialized
 */
union cvmx_dfa_ddr2_fcnt
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_fcnt_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_47_63               : 17;
	uint64_t fcyc_cnt                     : 47; /**< Counter counts FCLK cycles or \# cycles that the memory
                                                         controller has requests queued up depending on FCNT_MODE
                                                         If FCNT_MODE = 0, this counter counts the \# FCLK cycles
                                                         If FCNT_MODE = 1, this counter counts the \# cycles the
                                                         controller is active with memory requests. */
#else
	uint64_t fcyc_cnt                     : 47;
	uint64_t reserved_47_63               : 17;
#endif
	} s;
	struct cvmx_dfa_ddr2_fcnt_s           cn31xx;
};
typedef union cvmx_dfa_ddr2_fcnt cvmx_dfa_ddr2_fcnt_t;

/**
 * cvmx_dfa_ddr2_mrs
 *
 * DFA_DDR2_MRS = DDR2 MRS Register(s) MRS_DLL[14:0], MRS[14:0]
 * Description: This register contains the data driven onto the Address[14:0] lines during DDR INIT
 * To support Clamshelling (where N3K DFA_A[] pins are not 1:1 mapped to each clam(or rank), a HW init
 * sequence is allowed on a "per-rank" basis. Care must be taken in the values programmed into these
 * registers during the HW initialization sequence (see N3K specific restrictions in notes below).
 * DFA_DDR2_CFG[MRS_PGM] must be 1 to support this feature.
 *
 * Notes:
 * For DDR-II please consult your device's data sheet for further details:
 *
 */
union cvmx_dfa_ddr2_mrs
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_mrs_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_31_63               : 33;
	uint64_t mrs                          : 15; /**< Memory Address[14:0] during "MRS without resetting
                                                         DLL A[8]=0" step of HW initialization sequence.
                                                         (See JEDEC DDR2 specification (JESD79-2): Power Up
                                                         and initialization sequence - Step \#11).
                                                           A[14:13] = 0, RESERVED
                                                           A[12] = 0, Fast Active Power Down Mode
                                                           A[11:9] = DFA_DDR2_TMG[TWR]
                                                           A[8] = 0, for DLL Reset
                                                           A[7] =0  Test Mode (must be 0 for normal operation)
                                                           A[6:4]=DFA_DDR2_TMG[CASLAT] CAS LATENCY (default 4)
                                                           A[3]=0    Burst Type(must be 0:Sequential)
                                                           A[2:0]=2  Burst Length=4(default) */
	uint64_t reserved_15_15               : 1;
	uint64_t mrs_dll                      : 15; /**< Memory Address[14:0] during "MRS for DLL_RESET A[8]=1"
                                                         step of HW initialization sequence.
                                                         (See JEDEC DDR2 specification (JESD79-2): Power Up
                                                         and initialization sequence - Step \#8).
                                                           A[14:13] = 0, RESERVED
                                                           A[12] = 0, Fast Active Power Down Mode
                                                           A[11:9] = DFA_DDR2_TMG[TWR]
                                                           A[8] = 1, for DLL Reset
                                                           A[7] = 0  Test Mode (must be 0 for normal operation)
                                                           A[6:4]=DFA_DDR2_TMG[CASLAT]    CAS LATENCY (default 4)
                                                           A[3] = 0    Burst Type(must be 0:Sequential)
                                                           A[2:0] = 2  Burst Length=4(default) */
#else
	uint64_t mrs_dll                      : 15;
	uint64_t reserved_15_15               : 1;
	uint64_t mrs                          : 15;
	uint64_t reserved_31_63               : 33;
#endif
	} s;
	struct cvmx_dfa_ddr2_mrs_s            cn31xx;
};
typedef union cvmx_dfa_ddr2_mrs cvmx_dfa_ddr2_mrs_t;

/**
 * cvmx_dfa_ddr2_opt
 *
 * DFA_DDR2_OPT = DFA DDR2 Optimization Registers
 *
 *
 * Description: The following are registers to tweak certain parameters to boost performance
 */
union cvmx_dfa_ddr2_opt
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_opt_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_10_63               : 54;
	uint64_t max_read_batch               : 5;  /**< Maximum number of consecutive read to service before
                                                         allowing write to interrupt. */
	uint64_t max_write_batch              : 5;  /**< Maximum number of consecutive writes to service before
                                                         allowing reads to interrupt. */
#else
	uint64_t max_write_batch              : 5;
	uint64_t max_read_batch               : 5;
	uint64_t reserved_10_63               : 54;
#endif
	} s;
	struct cvmx_dfa_ddr2_opt_s            cn31xx;
};
typedef union cvmx_dfa_ddr2_opt cvmx_dfa_ddr2_opt_t;

/**
 * cvmx_dfa_ddr2_pll
 *
 * DFA_DDR2_PLL = DFA DDR2 PLL and DLL Configuration
 *
 *
 * Description: The following are registers to program the DDR2 PLL and DLL
 */
union cvmx_dfa_ddr2_pll
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_pll_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t pll_setting                  : 17; /**< Internal Debug Use Only */
	uint64_t reserved_32_46               : 15;
	uint64_t setting90                    : 5;  /**< Contains the setting of DDR DLL; Internal DBG only */
	uint64_t reserved_21_26               : 6;
	uint64_t dll_setting                  : 5;  /**< Contains the open loop setting value for the DDR90 delay
                                                         line. */
	uint64_t dll_byp                      : 1;  /**< DLL Bypass. When set, the DDR90 DLL is bypassed and
                                                         the DLL behaves in Open Loop giving a fixed delay
                                                         set by DLL_SETTING */
	uint64_t qdll_ena                     : 1;  /**< DDR Quad DLL Enable: A 0->1 transition on this bit after
                                                         erst deassertion will reset the DDR 90 DLL. Allow
                                                         200 micro seconds for Lock before DDR Init. */
	uint64_t bw_ctl                       : 4;  /**< Internal Use Only - for Debug */
	uint64_t bw_upd                       : 1;  /**< Internal Use Only - for Debug */
	uint64_t pll_div2                     : 1;  /**< PLL Output is further divided by 2. Useful for slow
                                                         fclk frequencies where the PLL may be out of range. */
	uint64_t reserved_7_7                 : 1;
	uint64_t pll_ratio                    : 5;  /**< Bits <6:2> sets the clk multiplication ratio
                                                         If the fclk frequency desired is less than 260MHz
                                                         (lower end saturation point of the pll), write 2x
                                                         the ratio desired in this register and set PLL_DIV2 */
	uint64_t pll_bypass                   : 1;  /**< PLL Bypass. Uses the ref_clk without multiplication. */
	uint64_t pll_init                     : 1;  /**< Need a 0 to 1 pulse on this CSR to get the DFA
                                                         Clk Generator Started. Write this register before
                                                         starting anything. Allow 200 uS for PLL Lock before
                                                         doing anything. */
#else
	uint64_t pll_init                     : 1;
	uint64_t pll_bypass                   : 1;
	uint64_t pll_ratio                    : 5;
	uint64_t reserved_7_7                 : 1;
	uint64_t pll_div2                     : 1;
	uint64_t bw_upd                       : 1;
	uint64_t bw_ctl                       : 4;
	uint64_t qdll_ena                     : 1;
	uint64_t dll_byp                      : 1;
	uint64_t dll_setting                  : 5;
	uint64_t reserved_21_26               : 6;
	uint64_t setting90                    : 5;
	uint64_t reserved_32_46               : 15;
	uint64_t pll_setting                  : 17;
#endif
	} s;
	struct cvmx_dfa_ddr2_pll_s            cn31xx;
};
typedef union cvmx_dfa_ddr2_pll cvmx_dfa_ddr2_pll_t;

/**
 * cvmx_dfa_ddr2_tmg
 *
 * DFA_DDR2_TMG = DFA DDR2 Memory Timing Config Register
 *
 *
 * Description: The following are registers to program the DDR2 memory timing parameters.
 */
union cvmx_dfa_ddr2_tmg
{
	uint64_t u64;
	struct cvmx_dfa_ddr2_tmg_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_47_63               : 17;
	uint64_t fcnt_mode                    : 1;  /**< If FCNT_MODE = 0, this counter counts the \# FCLK cycles
                                                         If FCNT_MODE = 1, this counter counts the \# cycles the
                                                         controller is active with memory requests. */
	uint64_t cnt_clr                      : 1;  /**< Clears the FCLK Cyc & Bus Util counter */
	uint64_t cavmipo                      : 1;  /**< RESERVED */
	uint64_t ctr_rst                      : 1;  /**< Reset oneshot pulse for refresh counter & Perf counters
                                                         SW should first write this field to a one to clear
                                                         & then write to a zero for normal operation */
	uint64_t odt_rtt                      : 2;  /**< DDR2 Termination Resistor Setting
                                                         These two bits are loaded into the RTT
                                                         portion of the EMRS register bits A6 & A2. If DDR2's
                                                         termination (for the memory's DQ/DQS/DM pads) is not
                                                         desired, set it to 00. If it is, chose between
                                                         01 for 75 ohm and 10 for 150 ohm termination.
                                                              00 = ODT Disabled
                                                              01 = 75 ohm Termination
                                                              10 = 150 ohm Termination
                                                              11 = 50 ohm Termination */
	uint64_t dqsn_ena                     : 1;  /**< For DDR-II Mode, DIC[1] is used to load into EMRS
                                                         bit 10 - DQSN Enable/Disable field. By default, we
                                                         program the DDR's to drive the DQSN also. Set it to
                                                         1 if DQSN should be Hi-Z.
                                                              0 - DQSN Enable
                                                              1 - DQSN Disable */
	uint64_t dic                          : 1;  /**< Drive Strength Control:
                                                         For DDR-I/II Mode, DIC[0] is
                                                         loaded into the Extended Mode Register (EMRS) A1 bit
                                                         during initialization. (see DDR-I data sheet EMRS
                                                         description)
                                                              0 = Normal
                                                              1 = Reduced */
	uint64_t r2r_slot                     : 1;  /**< A 1 on this register will force the controller to
                                                         slot a bubble between every reads */
	uint64_t tfaw                         : 5;  /**< tFAW - Cycles = RNDUP[tFAW(ns)/tcyc(ns)] - 1
                                                         Four Access Window time. Relevant only in
                                                         8-bank parts.
                                                              TFAW = 5'b0 for DDR2-4bank
                                                              TFAW = RNDUP[tFAW(ns)/tcyc(ns)] - 1 in DDR2-8bank */
	uint64_t twtr                         : 4;  /**< tWTR Cycles = RNDUP[tWTR(ns)/tcyc(ns)]
                                                         Last Wr Data to Rd Command time.
                                                         (Represented in fclk cycles)
                                                         TYP=15ns
                                                              - 0000: RESERVED
                                                              - 0001: 1
                                                              - ...
                                                              - 0111: 7
                                                              - 1000-1111: RESERVED */
	uint64_t twr                          : 3;  /**< DDR Write Recovery time (tWR). Last Wr Brst to Prech
                                                         This is not a direct encoding of the value. Its
                                                         programmed as below per DDR2 spec. The decimal number
                                                         on the right is RNDUP(tWR(ns) / clkFreq)
                                                         TYP=15ns
                                                              - 000: RESERVED
                                                              - 001: 2
                                                              - 010: 3
                                                              - 011: 4
                                                              - 100: 5
                                                              - 101: 6
                                                              - 110-111: RESERVED */
	uint64_t trp                          : 4;  /**< tRP Cycles = RNDUP[tRP(ns)/tcyc(ns)]
                                                         (Represented in fclk cycles)
                                                         TYP=15ns
                                                              - 0000: RESERVED
                                                              - 0001: 1
                                                              - ...
                                                              - 0111: 7
                                                              - 1000-1111: RESERVED
                                                         When using parts with 8 banks (DFA_CFG->MAX_BNK
                                                         is 1), load tRP cycles + 1 into this register. */
	uint64_t tras                         : 5;  /**< tRAS Cycles = RNDUP[tRAS(ns)/tcyc(ns)]
                                                         (Represented in fclk cycles)
                                                         TYP=45ns
                                                              - 00000-0001: RESERVED
                                                              - 00010: 2
                                                              - ...
                                                              - 10100: 20
                                                              - 10101-11111: RESERVED */
	uint64_t trrd                         : 3;  /**< tRRD cycles: ACT-ACT timing parameter for different
                                                         banks. (Represented in fclk cycles)
                                                         For DDR2, TYP=7.5ns
                                                             - 000: RESERVED
                                                             - 001: 1 tCYC
                                                             - 010: 2 tCYC
                                                             - 011: 3 tCYC
                                                             - 100: 4 tCYC
                                                             - 101: 5 tCYC
                                                             - 110-111: RESERVED */
	uint64_t trcd                         : 4;  /**< tRCD Cycles = RNDUP[tRCD(ns)/tcyc(ns)]
                                                         (Represented in fclk cycles)
                                                         TYP=15ns
                                                              - 0000: RESERVED
                                                              - 0001: 2 (2 is the smallest value allowed)
                                                              - 0002: 2
                                                              - ...
                                                              - 0111: 7
                                                              - 1110-1111: RESERVED */
	uint64_t addlat                       : 3;  /**< When in Posted CAS mode ADDLAT needs to be programmed
                                                         to tRCD-1
                                                               ADDLAT         \#additional latency cycles
                                                                000              0
                                                                001              1 (tRCD = 2 fclk's)
                                                                010              2 (tRCD = 3 fclk's)
                                                                011              3 (tRCD = 4 fclk's)
                                                                100              4 (tRCD = 5 fclk's)
                                                                101              5 (tRCD = 6 fclk's)
                                                                110              6 (tRCD = 7 fclk's)
                                                                111              7 (tRCD = 8 fclk's) */
	uint64_t pocas                        : 1;  /**< Posted CAS mode. When 1, we use DDR2's Posted CAS
                                                         feature. When using this mode, ADDLAT needs to be
                                                         programmed as well */
	uint64_t caslat                       : 3;  /**< CAS Latency in \# fclk Cycles
                                                         CASLAT           \#  CAS latency cycles
                                                          000 - 010           RESERVED
                                                          011                    3
                                                          100                    4
                                                          101                    5
                                                          110                    6
                                                          111                    7 */
	uint64_t tmrd                         : 2;  /**< tMRD Cycles
                                                         (Represented in fclk tCYC)
                                                         For DDR2, its TYP 2*tCYC)
                                                             - 000: RESERVED
                                                             - 001: 1
                                                             - 010: 2
                                                             - 011: 3 */
	uint64_t ddr2t                        : 1;  /**< When 2T mode is turned on, command signals are
                                                         setup a cycle ahead of when the CS is enabled
                                                         and kept for a total of 2 cycles. This mode is
                                                         enabled in higher speeds when there is difficulty
                                                         meeting setup. Performance could
                                                         be negatively affected in 2T mode */
#else
	uint64_t ddr2t                        : 1;
	uint64_t tmrd                         : 2;
	uint64_t caslat                       : 3;
	uint64_t pocas                        : 1;
	uint64_t addlat                       : 3;
	uint64_t trcd                         : 4;
	uint64_t trrd                         : 3;
	uint64_t tras                         : 5;
	uint64_t trp                          : 4;
	uint64_t twr                          : 3;
	uint64_t twtr                         : 4;
	uint64_t tfaw                         : 5;
	uint64_t r2r_slot                     : 1;
	uint64_t dic                          : 1;
	uint64_t dqsn_ena                     : 1;
	uint64_t odt_rtt                      : 2;
	uint64_t ctr_rst                      : 1;
	uint64_t cavmipo                      : 1;
	uint64_t cnt_clr                      : 1;
	uint64_t fcnt_mode                    : 1;
	uint64_t reserved_47_63               : 17;
#endif
	} s;
	struct cvmx_dfa_ddr2_tmg_s            cn31xx;
};
typedef union cvmx_dfa_ddr2_tmg cvmx_dfa_ddr2_tmg_t;

/**
 * cvmx_dfa_debug0
 *
 * DFA_DEBUG0 = DFA Scoreboard Debug \#0 Register
 * *FOR INTERNAL USE ONLY*
 * Description: When the DFA_CONTROL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_CONTROL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_debug0
{
	uint64_t u64;
	struct cvmx_dfa_debug0_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd0                         : 64; /**< DFA ScoreBoard \#0 Data
                                                         (DFA Scoreboard Debug)
                                                            [63:38]   (26) rptr[28:3]: Result Base Pointer (QW-aligned)
                                                            [37:22]   (16) Cumulative Result Write Counter (for HDR write)
                                                            [21]       (1) Waiting for GRdRsp EOT
                                                            [20]       (1) Waiting for GRdReq Issue (to NRQ)
                                                            [19]       (1) GLPTR/GLCNT Valid
                                                            [18]       (1) Completion Mark Detected
                                                            [17:15]    (3) Completion Code [0=PDGONE/1=PERR/2=RFULL/3=TERM]
                                                            [14]       (1) Completion Detected
                                                            [13]       (1) Waiting for HDR RWrCmtRsp
                                                            [12]       (1) Waiting for LAST RESULT RWrCmtRsp
                                                            [11]       (1) Waiting for HDR RWrReq
                                                            [10]        (1) Waiting for RWrReq
                                                            [9]        (1) Waiting for WQWrReq issue
                                                            [8]        (1) Waiting for PRdRsp EOT
                                                            [7]        (1) Waiting for PRdReq Issue (to NRQ)
                                                            [6]        (1) Packet Data Valid
                                                            [5]        (1) WQVLD
                                                            [4]        (1) WQ Done Point (either WQWrReq issued (for WQPTR<>0) OR HDR RWrCmtRsp)
                                                            [3]        (1) Resultant write STF/P Mode
                                                            [2]        (1) Packet Data LDT mode
                                                            [1]        (1) Gather Mode
                                                            [0]        (1) Valid */
#else
	uint64_t sbd0                         : 64;
#endif
	} s;
	struct cvmx_dfa_debug0_s              cn63xx;
	struct cvmx_dfa_debug0_s              cn63xxp1;
};
typedef union cvmx_dfa_debug0 cvmx_dfa_debug0_t;

/**
 * cvmx_dfa_debug1
 *
 * DFA_DEBUG1 = DFA Scoreboard Debug \#1 Register
 * *FOR INTERNAL USE ONLY*
 * Description: When the DFA_CONTROL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_CONTROL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_debug1
{
	uint64_t u64;
	struct cvmx_dfa_debug1_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd1                         : 64; /**< DFA ScoreBoard \#1 Data
                                                         DFA Scoreboard Debug Data
                                                            [63:56]   (8) UNUSED
                                                            [55:16]  (40) Packet Data Pointer
                                                            [15:0]   (16) Packet Data Counter */
#else
	uint64_t sbd1                         : 64;
#endif
	} s;
	struct cvmx_dfa_debug1_s              cn63xx;
	struct cvmx_dfa_debug1_s              cn63xxp1;
};
typedef union cvmx_dfa_debug1 cvmx_dfa_debug1_t;

/**
 * cvmx_dfa_debug2
 *
 * DFA_DEBUG2 = DFA Scoreboard Debug \#2 Register
 *
 * Description: When the DFA_CONTROL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_CONTROL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_debug2
{
	uint64_t u64;
	struct cvmx_dfa_debug2_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd2                         : 64; /**< DFA ScoreBoard \#2 Data
                                                         [63:45] (19) UNUSED
                                                         [44:42]  (3) Instruction Type
                                                         [41:5]  (37) rwptr[39:3]: Result Write Pointer
                                                         [4:0]    (5) prwcnt[4:0]: Pending Result Write Counter */
#else
	uint64_t sbd2                         : 64;
#endif
	} s;
	struct cvmx_dfa_debug2_s              cn63xx;
	struct cvmx_dfa_debug2_s              cn63xxp1;
};
typedef union cvmx_dfa_debug2 cvmx_dfa_debug2_t;

/**
 * cvmx_dfa_debug3
 *
 * DFA_DEBUG3 = DFA Scoreboard Debug \#3 Register
 *
 * Description: When the DFA_CONTROL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_CONTROL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_debug3
{
	uint64_t u64;
	struct cvmx_dfa_debug3_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd3                         : 64; /**< DFA ScoreBoard \#3 Data
                                                         [63:52] (11) rptr[39:29]: Result Base Pointer (QW-aligned)
                                                         [52:16] (37) glptr[39:3]: Gather List Pointer
                                                         [15:0]  (16) glcnt Gather List Counter */
#else
	uint64_t sbd3                         : 64;
#endif
	} s;
	struct cvmx_dfa_debug3_s              cn63xx;
	struct cvmx_dfa_debug3_s              cn63xxp1;
};
typedef union cvmx_dfa_debug3 cvmx_dfa_debug3_t;

/**
 * cvmx_dfa_difctl
 *
 * DFA_DIFCTL = DFA Instruction FIFO (DIF) Control Register
 *
 * Description:
 *  NOTE: To write to the DFA_DIFCTL register, a device would issue an IOBST directed at the DFA with addr[34:32]=3'b110.
 *        To read the DFA_DIFCTL register, a device would issue an IOBLD64 directed at the DFA with addr[34:32]=3'b110.
 *
 *  NOTE: This register is intended to ONLY be written once (at power-up). Any future writes could
 *  cause the DFA and FPA HW to become unpredictable.
 *
 *  NOTE: If DFA_CONFIG[DTECLKDIS]=1 (DFA-DTE clocks disabled), reads/writes to the DFA_DIFCTL register do not take effect.
 *  NOTE: If FUSE[TBD]="DFA DTE disable" is blown, reads/writes to the DFA_DIFCTL register do not take effect.
 */
union cvmx_dfa_difctl
{
	uint64_t u64;
	struct cvmx_dfa_difctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_20_63               : 44;
	uint64_t dwbcnt                       : 8;  /**< Represents the \# of cache lines in the instruction
                                                         buffer that may be dirty and should not be
                                                         written-back to memory when the instruction
                                                         chunk is returned to the Free Page list.
                                                         NOTE: Typically SW will want to mark all DFA
                                                         Instruction memory returned to the Free Page list
                                                         as DWB (Don't WriteBack), therefore SW should
                                                         seed this register as:
                                                           DFA_DIFCTL[DWBCNT] = (DFA_DIFCTL[SIZE] + 4)/4 */
	uint64_t pool                         : 3;  /**< Represents the 3bit buffer pool-id  used by DFA HW
                                                         when the DFA instruction chunk is recycled back
                                                         to the Free Page List maintained by the FPA HW
                                                         (once the DFA instruction has been issued). */
	uint64_t size                         : 9;  /**< Represents the \# of 32B instructions contained
                                                         within each DFA instruction chunk. At Power-on,
                                                         SW will seed the SIZE register with a fixed
                                                         chunk-size. (Must be at least 3)
                                                         DFA HW uses this field to determine the size
                                                         of each DFA instruction chunk, in order to:
                                                            a) determine when to read the next DFA
                                                               instruction chunk pointer which is
                                                               written by SW at the end of the current
                                                               DFA instruction chunk (see DFA description
                                                               of next chunk buffer Ptr for format).
                                                            b) determine when a DFA instruction chunk
                                                               can be returned to the Free Page List
                                                               maintained by the FPA HW. */
#else
	uint64_t size                         : 9;
	uint64_t pool                         : 3;
	uint64_t dwbcnt                       : 8;
	uint64_t reserved_20_63               : 44;
#endif
	} s;
	struct cvmx_dfa_difctl_s              cn31xx;
	struct cvmx_dfa_difctl_s              cn38xx;
	struct cvmx_dfa_difctl_s              cn38xxp2;
	struct cvmx_dfa_difctl_s              cn58xx;
	struct cvmx_dfa_difctl_s              cn58xxp1;
	struct cvmx_dfa_difctl_s              cn63xx;
	struct cvmx_dfa_difctl_s              cn63xxp1;
};
typedef union cvmx_dfa_difctl cvmx_dfa_difctl_t;

/**
 * cvmx_dfa_difrdptr
 *
 * DFA_DIFRDPTR = DFA Instruction FIFO (DIF) RDPTR Register
 *
 * Description:
 *  NOTE: To write to the DFA_DIFRDPTR register, a device would issue an IOBST directed at the DFA with addr[34:33]=2'b01.
 *        To read the DFA_DIFRDPTR register, a device would issue an IOBLD64 directed at the DFA with addr[34:33]=2'b01.
 *
 *  NOTE: If DFA_CONFIG[DTECLKDIS]=1 (DFA-DTE clocks disabled), reads/writes to the DFA_DIFRDPTR register do not take effect.
 *  NOTE: If FUSE[TBD]="DFA DTE disable" is blown, reads/writes to the DFA_DIFRDPTR register do not take effect.
 */
union cvmx_dfa_difrdptr
{
	uint64_t u64;
	struct cvmx_dfa_difrdptr_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_40_63               : 24;
	uint64_t rdptr                        : 35; /**< Represents the 32B-aligned address of the current
                                                         instruction in the DFA Instruction FIFO in main
                                                         memory. The RDPTR must be seeded by software at
                                                         boot time, and is then maintained thereafter
                                                         by DFA HW.
                                                         During the seed write (by SW), RDPTR[6:5]=0,
                                                         since DFA instruction chunks must be 128B aligned.
                                                         During a read (by SW), the 'most recent' contents
                                                         of the RDPTR register are returned at the time
                                                         the NCB-INB bus is driven.
                                                         NOTE: Since DFA HW updates this register, its
                                                         contents are unpredictable in SW (unless
                                                         its guaranteed that no new DoorBell register
                                                         writes have occurred and the DoorBell register is
                                                         read as zero). */
	uint64_t reserved_0_4                 : 5;
#else
	uint64_t reserved_0_4                 : 5;
	uint64_t rdptr                        : 35;
	uint64_t reserved_40_63               : 24;
#endif
	} s;
	struct cvmx_dfa_difrdptr_cn31xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_36_63               : 28;
	uint64_t rdptr                        : 31; /**< Represents the 32B-aligned address of the current
                                                         instruction in the DFA Instruction FIFO in main
                                                         memory. The RDPTR must be seeded by software at
                                                         boot time, and is then maintained thereafter
                                                         by DFA HW.
                                                         During the seed write (by SW), RDPTR[6:5]=0,
                                                         since DFA instruction chunks must be 128B aligned.
                                                         During a read (by SW), the 'most recent' contents
                                                         of the RDPTR register are returned at the time
                                                         the NCB-INB bus is driven.
                                                         NOTE: Since DFA HW updates this register, its
                                                         contents are unpredictable in SW (unless
                                                         its guaranteed that no new DoorBell register
                                                         writes have occurred and the DoorBell register is
                                                         read as zero). */
	uint64_t reserved_0_4                 : 5;
#else
	uint64_t reserved_0_4                 : 5;
	uint64_t rdptr                        : 31;
	uint64_t reserved_36_63               : 28;
#endif
	} cn31xx;
	struct cvmx_dfa_difrdptr_cn31xx       cn38xx;
	struct cvmx_dfa_difrdptr_cn31xx       cn38xxp2;
	struct cvmx_dfa_difrdptr_cn31xx       cn58xx;
	struct cvmx_dfa_difrdptr_cn31xx       cn58xxp1;
	struct cvmx_dfa_difrdptr_s            cn63xx;
	struct cvmx_dfa_difrdptr_s            cn63xxp1;
};
typedef union cvmx_dfa_difrdptr cvmx_dfa_difrdptr_t;

/**
 * cvmx_dfa_dtcfadr
 *
 * DFA_DTCFADR = DFA DTC Failing Address Register
 *
 * Description: DFA Node Cache Failing Address/Control Error Capture information
 * This register contains useful information to help in isolating a Node Cache RAM failure.
 * NOTE: The first detected PERR failure is captured in DFA_DTCFADR (locked down), until the
 * corresponding PERR Interrupt is cleared by writing one (W1C). (see: DFA_ERR[DC0PERR[2:0]]).
 */
union cvmx_dfa_dtcfadr
{
	uint64_t u64;
	struct cvmx_dfa_dtcfadr_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_44_63               : 20;
	uint64_t ram3fadr                     : 12; /**< DFA RAM3 Failing Address
                                                         If DFA_ERR[DC0PERR<2>]=1, this field indicates the
                                                         failing RAM3 Address. The failing address is locked
                                                         down until the DC0PERR<2> W1C occurs. */
	uint64_t reserved_25_31               : 7;
	uint64_t ram2fadr                     : 9;  /**< DFA RAM2 Failing Address
                                                         If DFA_ERR[DC0PERR<1>]=1, this field indicates the
                                                         failing RAM2 Address. The failing address is locked
                                                         down until the DC0PERR<1> W1C occurs. */
	uint64_t reserved_14_15               : 2;
	uint64_t ram1fadr                     : 14; /**< DFA RAM1 Failing Address
                                                         If DFA_ERR[DC0PERR<0>]=1, this field indicates the
                                                         failing RAM1 Address. The failing address is locked
                                                         down until the DC0PERR<0> W1C occurs. */
#else
	uint64_t ram1fadr                     : 14;
	uint64_t reserved_14_15               : 2;
	uint64_t ram2fadr                     : 9;
	uint64_t reserved_25_31               : 7;
	uint64_t ram3fadr                     : 12;
	uint64_t reserved_44_63               : 20;
#endif
	} s;
	struct cvmx_dfa_dtcfadr_s             cn63xx;
	struct cvmx_dfa_dtcfadr_s             cn63xxp1;
};
typedef union cvmx_dfa_dtcfadr cvmx_dfa_dtcfadr_t;

/**
 * cvmx_dfa_eclkcfg
 *
 * Specify the RSL base addresses for the block
 *
 *                  DFA_ECLKCFG = DFA eclk-domain Configuration Registers
 *
 * Description:
 */
union cvmx_dfa_eclkcfg
{
	uint64_t u64;
	struct cvmx_dfa_eclkcfg_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_19_63               : 45;
	uint64_t sbdnum                       : 3;  /**< SBD Debug Entry#
                                                         For internal use only. (DFA Scoreboard debug)
                                                         Selects which one of 8 DFA Scoreboard entries is
                                                         latched into the DFA_SBD_DBG[0-3] registers. */
	uint64_t reserved_15_15               : 1;
	uint64_t sbdlck                       : 1;  /**< DFA Scoreboard LOCK Strobe
                                                         For internal use only. (DFA Scoreboard debug)
                                                         When written with a '1', the DFA Scoreboard Debug
                                                         registers (DFA_SBD_DBG[0-3]) are all locked down.
                                                         This allows SW to lock down the contents of the entire
                                                         SBD for a single instant in time. All subsequent reads
                                                         of the DFA scoreboard registers will return the data
                                                         from that instant in time. */
	uint64_t dcmode                       : 1;  /**< DRF-CRQ/DTE Arbiter Mode
                                                         DTE-DRF Arbiter (0=FP [LP=CRQ/HP=DTE],1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t dtmode                       : 1;  /**< DRF-DTE Arbiter Mode
                                                         DTE-DRF Arbiter (0=FP [LP=DTE[15],...,HP=DTE[0]],1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t pmode                        : 1;  /**< NCB-NRP Arbiter Mode
                                                         (0=Fixed Priority [LP=WQF,DFF,HP=RGF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t qmode                        : 1;  /**< NCB-NRQ Arbiter Mode
                                                         (0=Fixed Priority [LP=IRF,RWF,PRF,HP=GRF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t imode                        : 1;  /**< NCB-Inbound Arbiter
                                                         (0=FP [LP=NRQ,HP=NRP], 1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t sarb                         : 1;  /**< DFA Source Arbiter Mode
                                                         Selects the arbitration mode used to select DFA requests
                                                         issued from either CP2 or the DTE (NCB-CSR or DFA HW engine).
                                                          - 0: Fixed Priority [Highest=CP2, Lowest=DTE]
                                                          - 1: Round-Robin
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t reserved_3_7                 : 5;
	uint64_t dteclkdis                    : 1;  /**< DFA DTE Clock Disable
                                                         When SET, the DFA clocks for DTE(thread engine)
                                                         operation are disabled.
                                                         NOTE: When SET, SW MUST NEVER issue ANY operations to
                                                         the DFA via the NCB Bus. All DFA Operations must be
                                                         issued solely through the CP2 interface. */
	uint64_t maxbnk                       : 1;  /**< Maximum Banks per-device (used by the address mapper
                                                         when extracting address bits for the memory bank#.
                                                                 - 0: 4 banks/device
                                                                 - 1: 8 banks/device */
	uint64_t dfa_frstn                    : 1;  /**< Hold this 0 until the DFA DDR PLL and DLL lock
                                                         and then write a 1. A 1 on this register deasserts
                                                         the internal frst_n. Refer to DFA_DDR2_PLL registers for more
                                                         startup information.
                                                         Startup sequence if DFA interface needs to be ON:
                                                          After valid power up,
                                                          Write DFA_DDR2_PLL-> PLL_RATIO & PLL_DIV2 & PLL_BYPASS
                                                          to the appropriate values
                                                          Wait a few cycles
                                                          Write a 1 DFA_DDR2_PLL -> PLL_INIT
                                                          Wait 100 microseconds
                                                          Write a 1 to DFA_DDR2_PLL -> QDLL_ENA
                                                          Wait 10 microseconds
                                                          Write a 1 to this register DFA_FRSTN to pull DFA out of
                                                          reset
                                                          Now the DFA block is ready to be initialized (follow the
                                                          DDR init sequence). */
#else
	uint64_t dfa_frstn                    : 1;
	uint64_t maxbnk                       : 1;
	uint64_t dteclkdis                    : 1;
	uint64_t reserved_3_7                 : 5;
	uint64_t sarb                         : 1;
	uint64_t imode                        : 1;
	uint64_t qmode                        : 1;
	uint64_t pmode                        : 1;
	uint64_t dtmode                       : 1;
	uint64_t dcmode                       : 1;
	uint64_t sbdlck                       : 1;
	uint64_t reserved_15_15               : 1;
	uint64_t sbdnum                       : 3;
	uint64_t reserved_19_63               : 45;
#endif
	} s;
	struct cvmx_dfa_eclkcfg_s             cn31xx;
};
typedef union cvmx_dfa_eclkcfg cvmx_dfa_eclkcfg_t;

/**
 * cvmx_dfa_err
 *
 * DFA_ERR = DFA ERROR Register
 *
 * Description:
 */
union cvmx_dfa_err
{
	uint64_t u64;
	struct cvmx_dfa_err_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_33_63               : 31;
	uint64_t dblina                       : 1;  /**< Doorbell Overflow Interrupt Enable bit.
                                                         When set, doorbell overflow conditions are reported. */
	uint64_t dblovf                       : 1;  /**< Doorbell Overflow detected - Status bit
                                                         When set, the 20b accumulated doorbell register
                                                         had overflowed (SW wrote too many doorbell requests).
                                                         If the DBLINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         NOTE: Detection of a Doorbell Register overflow
                                                         is a catastrophic error which may leave the DFA
                                                         HW in an unrecoverable state. */
	uint64_t cp2pina                      : 1;  /**< CP2 LW Mode Parity Error Interrupt Enable bit.
                                                         When set, all PP-generated LW Mode read
                                                         transactions which encounter a parity error (across
                                                         the 36b of data) are reported. */
	uint64_t cp2perr                      : 1;  /**< PP-CP2 Parity Error Detected - Status bit
                                                         When set, a parity error had been detected for a
                                                         PP-generated LW Mode read transaction.
                                                         If the CP2PINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         See also: DFA_MEMFADR CSR which contains more data
                                                         about the memory address/control to help isolate
                                                         the failure. */
	uint64_t cp2parena                    : 1;  /**< CP2 LW Mode Parity Error Enable
                                                         When set, all PP-generated LW Mode read
                                                         transactions which encounter a parity error (across
                                                         the 36b of data) are reported.
                                                         NOTE: This signal must only be written to a different
                                                         value when there are no PP-CP2 transactions
                                                         (preferrably during power-on software initialization). */
	uint64_t dtepina                      : 1;  /**< DTE Parity Error Interrupt Enable bit
                                                         (for 18b SIMPLE mode ONLY).
                                                         When set, all DTE-generated 18b SIMPLE Mode read
                                                         transactions which encounter a parity error (across
                                                         the 17b of data) are reported. */
	uint64_t dteperr                      : 1;  /**< DTE Parity Error Detected (for 18b SIMPLE mode ONLY)
                                                         When set, all DTE-generated 18b SIMPLE Mode read
                                                         transactions which encounter a parity error (across
                                                         the 17b of data) are reported. */
	uint64_t dteparena                    : 1;  /**< DTE Parity Error Enable (for 18b SIMPLE mode ONLY)
                                                         When set, all DTE-generated 18b SIMPLE Mode read
                                                         transactions which encounter a parity error (across
                                                         the 17b of data) are reported.
                                                         NOTE: This signal must only be written to a different
                                                         value when there are no DFA thread engines active
                                                         (preferrably during power-on). */
	uint64_t dtesyn                       : 7;  /**< DTE 29b ECC Failing 6bit Syndrome
                                                         When DTESBE or DTEDBE are set, this field contains
                                                         the failing 7b ECC syndrome. */
	uint64_t dtedbina                     : 1;  /**< DTE 29b Double Bit Error Interrupt Enable bit
                                                         When set, an interrupt is posted for any DTE-generated
                                                         36b SIMPLE Mode read which encounters a double bit
                                                         error. */
	uint64_t dtesbina                     : 1;  /**< DTE 29b Single Bit Error Interrupt Enable bit
                                                         When set, an interrupt is posted for any DTE-generated
                                                         36b SIMPLE Mode read which encounters a single bit
                                                         error (which is also corrected). */
	uint64_t dtedbe                       : 1;  /**< DTE 29b Double Bit Error Detected - Status bit
                                                         When set, a double bit error had been detected
                                                         for a DTE-generated 36b SIMPLE Mode read transaction.
                                                         The DTESYN contains the failing syndrome.
                                                         If the DTEDBINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         See also: DFA_MEMFADR CSR which contains more data
                                                         about the memory address/control to help isolate
                                                         the failure.
                                                         NOTE: DTE-generated 18b SIMPLE Mode Read transactions
                                                         do not participate in ECC check/correct). */
	uint64_t dtesbe                       : 1;  /**< DTE 29b Single Bit Error Corrected - Status bit
                                                         When set, a single bit error had been detected and
                                                         corrected for a DTE-generated 36b SIMPLE Mode read
                                                         transaction.
                                                         If the DTEDBE=0, then the DTESYN contains the
                                                         failing syndrome (used during correction).
                                                         NOTE: DTE-generated 18b SIMPLE Mode Read
                                                         transactions do not participate in ECC check/correct).
                                                         If the DTESBINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         See also: DFA_MEMFADR CSR which contains more data
                                                         about the memory address/control to help isolate
                                                         the failure. */
	uint64_t dteeccena                    : 1;  /**< DTE 29b ECC Enable (for 36b SIMPLE mode ONLY)
                                                         When set, 29b ECC is enabled on all DTE-generated
                                                         36b SIMPLE Mode read transactions.
                                                         NOTE: This signal must only be written to a different
                                                         value when there are no DFA thread engines active
                                                         (preferrably during power-on software initialization). */
	uint64_t cp2syn                       : 8;  /**< PP-CP2 QW ECC Failing 8bit Syndrome
                                                         When CP2SBE or CP2DBE are set, this field contains
                                                         the failing ECC 8b syndrome.
                                                         Refer to CP2ECCENA. */
	uint64_t cp2dbina                     : 1;  /**< PP-CP2 Double Bit Error Interrupt Enable bit
                                                         When set, an interrupt is posted for any PP-generated
                                                         QW Mode read which encounters a double bit error.
                                                         Refer to CP2DBE. */
	uint64_t cp2sbina                     : 1;  /**< PP-CP2 Single Bit Error Interrupt Enable bit
                                                         When set, an interrupt is posted for any PP-generated
                                                         QW Mode read which encounters a single bit error
                                                         (which is also corrected).
                                                         Refer to CP2SBE. */
	uint64_t cp2dbe                       : 1;  /**< PP-CP2 Double Bit Error Detected - Status bit
                                                         When set, a double bit error had been detected
                                                         for a PP-generated QW Mode read transaction.
                                                         The CP2SYN contains the failing syndrome.
                                                          NOTE: PP-generated LW Mode Read transactions
                                                         do not participate in ECC check/correct).
                                                         Refer to CP2ECCENA.
                                                         If the CP2DBINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         See also: DFA_MEMFADR CSR which contains more data
                                                         about the memory address/control to help isolate
                                                         the failure. */
	uint64_t cp2sbe                       : 1;  /**< PP-CP2 Single Bit Error Corrected - Status bit
                                                         When set, a single bit error had been detected and
                                                         corrected for a PP-generated QW Mode read
                                                         transaction.
                                                         If the CP2DBE=0, then the CP2SYN contains the
                                                         failing syndrome (used during correction).
                                                         Refer to CP2ECCENA.
                                                         If the CP2SBINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         See also: DFA_MEMFADR CSR which contains more data
                                                         about the memory address/control to help isolate
                                                         the failure.
                                                         NOTE: PP-generated LW Mode Read transactions
                                                         do not participate in ECC check/correct). */
	uint64_t cp2eccena                    : 1;  /**< PP-CP2 QW ECC Enable (for QW Mode transactions)
                                                         When set, 8bit QW ECC is enabled on all PP-generated
                                                         QW Mode read transactions, CP2SBE and
                                                         CP2DBE may be set, and CP2SYN may be filled.
                                                         NOTE: This signal must only be written to a different
                                                         value when there are no PP-CP2 transactions
                                                         (preferrably during power-on software initialization).
                                                         NOTE: QW refers to a 64-bit LLM Load/Store (intiated
                                                         by a processor core). LW refers to a 36-bit load/store. */
#else
	uint64_t cp2eccena                    : 1;
	uint64_t cp2sbe                       : 1;
	uint64_t cp2dbe                       : 1;
	uint64_t cp2sbina                     : 1;
	uint64_t cp2dbina                     : 1;
	uint64_t cp2syn                       : 8;
	uint64_t dteeccena                    : 1;
	uint64_t dtesbe                       : 1;
	uint64_t dtedbe                       : 1;
	uint64_t dtesbina                     : 1;
	uint64_t dtedbina                     : 1;
	uint64_t dtesyn                       : 7;
	uint64_t dteparena                    : 1;
	uint64_t dteperr                      : 1;
	uint64_t dtepina                      : 1;
	uint64_t cp2parena                    : 1;
	uint64_t cp2perr                      : 1;
	uint64_t cp2pina                      : 1;
	uint64_t dblovf                       : 1;
	uint64_t dblina                       : 1;
	uint64_t reserved_33_63               : 31;
#endif
	} s;
	struct cvmx_dfa_err_s                 cn31xx;
	struct cvmx_dfa_err_s                 cn38xx;
	struct cvmx_dfa_err_s                 cn38xxp2;
	struct cvmx_dfa_err_s                 cn58xx;
	struct cvmx_dfa_err_s                 cn58xxp1;
};
typedef union cvmx_dfa_err cvmx_dfa_err_t;

/**
 * cvmx_dfa_error
 *
 * DFA_ERROR = DFA ERROR Register
 *
 * Description:
 */
union cvmx_dfa_error
{
	uint64_t u64;
	struct cvmx_dfa_error_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_17_63               : 47;
	uint64_t cndrd                        : 1;  /**< If DC0PERR[0]=1 indicating a RAM1 Parity error,
                                                         this additional bit further specifies that the
                                                         RAM1 parity error was detected during a CND-RD
                                                         (Cache Node Metadata Read).

                                                         For CNDRD Parity Error, the previous CNA arc fetch
                                                         information is written to RWORD1+ as follows:
                                                            RWORD1+[NTYPE]=MNODE
                                                            RWORD1+[NDNID]=cna.ndnid
                                                            RWORD1+[NHMSK]=cna.hmsk
                                                            RWORD1+[NNPTR]=cna.nnptr[13:0] */
	uint64_t reserved_4_15                : 12;
	uint64_t dc0perr                      : 3;  /**< RAM[3:1] Parity Error Detected from Node Cluster \#0
                                                         See also DFA_DTCFADR register which contains the
                                                         failing addresses for the internal node cache RAMs. */
	uint64_t dblovf                       : 1;  /**< Doorbell Overflow detected - Status bit
                                                         When set, the 20b accumulated doorbell register
                                                         had overflowed (SW wrote too many doorbell requests).
                                                         If the DBLINA had previously been enabled(set),
                                                         an interrupt will be posted. Software can clear
                                                         the interrupt by writing a 1 to this register bit.
                                                         NOTE: Detection of a Doorbell Register overflow
                                                         is a catastrophic error which may leave the DFA
                                                         HW in an unrecoverable state. */
#else
	uint64_t dblovf                       : 1;
	uint64_t dc0perr                      : 3;
	uint64_t reserved_4_15                : 12;
	uint64_t cndrd                        : 1;
	uint64_t reserved_17_63               : 47;
#endif
	} s;
	struct cvmx_dfa_error_s               cn63xx;
	struct cvmx_dfa_error_s               cn63xxp1;
};
typedef union cvmx_dfa_error cvmx_dfa_error_t;

/**
 * cvmx_dfa_intmsk
 *
 * DFA_INTMSK = DFA ERROR Interrupt Mask Register
 *
 * Description:
 */
union cvmx_dfa_intmsk
{
	uint64_t u64;
	struct cvmx_dfa_intmsk_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_4_63                : 60;
	uint64_t dc0pena                      : 3;  /**< RAM[3:1] Parity Error Enabled Node Cluster \#0 */
	uint64_t dblina                       : 1;  /**< Doorbell Overflow Interrupt Enable bit.
                                                         When set, doorbell overflow conditions are reported. */
#else
	uint64_t dblina                       : 1;
	uint64_t dc0pena                      : 3;
	uint64_t reserved_4_63                : 60;
#endif
	} s;
	struct cvmx_dfa_intmsk_s              cn63xx;
	struct cvmx_dfa_intmsk_s              cn63xxp1;
};
typedef union cvmx_dfa_intmsk cvmx_dfa_intmsk_t;

/**
 * cvmx_dfa_memcfg0
 *
 * DFA_MEMCFG0 = DFA Memory Configuration
 *
 * Description:
 */
union cvmx_dfa_memcfg0
{
	uint64_t u64;
	struct cvmx_dfa_memcfg0_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_32_63               : 32;
	uint64_t rldqck90_rst                 : 1;  /**< RLDCK90 and RLDQK90 DLL SW Reset
                                                         When written with a '1' the RLDCK90 and RLDQK90 DLL are
                                                         in soft-reset. */
	uint64_t rldck_rst                    : 1;  /**< RLDCK Zero Delay DLL(Clock Generator) SW Reset
                                                         When written with a '1' the RLDCK zero delay DLL is in
                                                         soft-reset. */
	uint64_t clkdiv                       : 2;  /**< RLDCLK Divisor Select
                                                           - 0: RLDx_CK_H/L = Core Clock /2
                                                           - 1: RESERVED (must not be used)
                                                           - 2: RLDx_CK_H/L = Core Clock /3
                                                           - 3: RLDx_CK_H/L = Core Clock /4
                                                         The DFA LLM interface(s) are tied to the core clock
                                                         frequency through this programmable clock divisor.
                                                         Examples:
                                                            Core Clock(MHz) | DFA-LLM Clock(MHz) | CLKDIV
                                                           -----------------+--------------------+--------
                                                                 800        |    400/(800-DDR)   |  /2
                                                                1000        |    333/(666-DDR)   |  /3
                                                                 800        |    200/(400-DDR)   |  /4
                                                         NOTE: This value MUST BE programmed BEFORE doing a
                                                         Hardware init sequence (see: DFA_MEMCFG0[INIT_Px] bits). */
	uint64_t lpp_ena                      : 1;  /**< PP Linear Port Addressing Mode Enable
                                                         When enabled, PP-core LLM accesses to the lower-512MB
                                                         LLM address space are sent to the single DFA port
                                                         which is enabled. NOTE: If LPP_ENA=1, only
                                                         one DFA RLDRAM port may be enabled for RLDRAM accesses
                                                         (ie: ENA_P0 and ENA_P1 CAN NEVER BOTH be set).
                                                         PP-core LLM accesses to the upper-512MB LLM address
                                                         space are sent to the other 'disabled' DFA port.
                                                         SW RESTRICTION: If LPP_ENA=1, then only one DFA port
                                                         may be enabled for RLDRAM accesses (ie: ENA_P0 and
                                                         ENA_P1 CAN NEVER BOTH be set).
                                                         NOTE: This bit is used to allow PP-Core LLM accesses to a
                                                         disabled port, such that each port can be sequentially
                                                         addressed (ie: disable LW address interleaving).
                                                         Enabling this bit allows BOTH PORTs to be active and
                                                         sequentially addressable. The single port that is
                                                         enabled(ENA_Px) will respond to the low-512MB LLM address
                                                         space, and the other 'disabled' port will respond to the
                                                         high-512MB LLM address space.
                                                         Example usage:
                                                            - DFA RLD0 pins used for TCAM-FPGA(CP2 accesses)
                                                            - DFA RLD1 pins used for RLDRAM (DTE/CP2 accesses).
                                                         USAGE NOTE:
                                                         If LPP_ENA=1 and SW DOES NOT initialize the disabled port
                                                         (ie: INIT_Px=0->1), then refreshes and the HW init
                                                         sequence WILL NOT occur for the disabled port.
                                                         If LPP_ENA=1 and SW does initialize the disabled port
                                                         (INIT_Px=0->1 with ENA_Px=0), then refreshes and
                                                         the HW init sequence WILL occur to the disabled port. */
	uint64_t bunk_init                    : 2;  /**< Controls the CS_N[1:0] during a) a HW Initialization
                                                         sequence (triggered by DFA_MEMCFG0[INIT_Px]) or
                                                         b) during a normal refresh sequence. If
                                                         the BNK_INIT[x]=1, the corresponding CS_N[x] is driven.
                                                         NOTE: This is required for DRAM used in a
                                                         clamshell configuration, since the address lines
                                                         carry Mode Register write data that is unique
                                                         per bunk(or clam). In a clamshell configuration,
                                                         The N3K A[x] pin may be tied into Clam#0's A[x]
                                                         and also into Clam#1's 'mirrored' address bit A[y]
                                                         (eg: Clam0 sees A[5] and Clam1 sees A[15]).
                                                         To support clamshell designs, SW must initiate
                                                         two separate HW init sequences for the two bunks
                                                         (or clams) . Before each HW init sequence is triggered,
                                                         SW must preload the DFA_MEMRLD[22:0] with the data
                                                         that will be driven onto the A[22:0] wires during
                                                         an MRS mode register write.
                                                         NOTE: After the final HW initialization sequence has
                                                         been triggered, SW must wait 64K eclks before writing
                                                         the BUNK_INIT[1:0] field = 3'b11 (so that CS_N[1:0] is
                                                         driven during refresh sequences in normal operation.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t init_p0                      : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for Memory Port \#0 is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Set up the DFA_MEMCFG0[CLKDIV] ratio for intended
                                                              RLDRAM operation.
                                                                [legal values 0: DIV2 2: DIV3 3: DIV4]
                                                           2) Write a '1' into BOTH the DFA_MEM_CFG0[RLDCK_RST]
                                                              and DFA_MEM_CFG0[RLDQCK90_RST] field at
                                                              the SAME TIME. This step puts all three DLLs in
                                                              SW reset (RLDCK, RLDCK90, RLDQK90 DLLs).
                                                           3) Write a '0' into the DFA_MEM_CFG0[RLDCK_RST] field.
                                                              This step takes the RLDCK DLL out of soft-reset so
                                                              that the DLL can generate the RLDx_CK_H/L clock pins.
                                                           4) Wait 1ms (for RLDCK DLL to achieve lock)
                                                           5) Write a '0' into DFA_MEM_CFG0[RLDQCK90_RST] field.
                                                              This step takes the RLDCK90 DLL AND RLDQK90 DLL out
                                                              of soft-reset.
                                                           6) Wait 1ms (for RLDCK90/RLDQK90 DLLs to achieve lock)
                                                           7) Enable memory port(s):  ENA_P0=1/ENA_P1=1
                                                           8) Wait 100us (to ensure a stable clock
                                                              to the RLDRAMs) - as per RLDRAM spec.
                                                           - - - - - Hardware Initialization Sequence - - - - -
                                                           9) Setup the DFA_MEMCFG0[BUNK_INIT] for the bunk(s)
                                                              intended to be initialized.
                                                          10) Write a '1' to the corresponding INIT_Px which
                                                              will initiate a hardware initialization
                                                              sequence to that'specific' port.
                                                          11) Wait (DFA_MEMCFG0[CLKDIV] * 32K) eclk cycles.
                                                              [to ensure the HW init sequence has completed
                                                              before writing to ANY of the DFA_MEM* registers]
                                                           - - - - - Hardware Initialization Sequence - - - - -
                                                          12) Write the DFA_MEMCFG0[BUNK_INIT]=3 to enable
                                                              refreshes to BOTH bunks.
                                                         NOTE: In some cases (where the address wires are routed
                                                         differently between the front and back 'bunks'),
                                                         SW will need to use DFA_MEMCFG0[BUNK_INIT] bits to
                                                         control the Hardware initialization sequence for a
                                                         'specific bunk'. In these cases, SW would setup the
                                                         BUNK_INIT and repeat Steps \#9-11 for each bunk/port.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: DFA Memory Port#0 corresponds to the Octeon
                                                         RLD0_* pins. */
	uint64_t init_p1                      : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for Memory Port \#1 is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Set up the DFA_MEMCFG0[CLKDIV] ratio for intended
                                                              RLDRAM operation.
                                                                [legal values 0: DIV2 2: DIV3 3: DIV4]
                                                           2) Write a '1' into BOTH the DFA_MEM_CFG0[RLDCK_RST]
                                                              and DFA_MEM_CFG0[RLDQCK90_RST] field at
                                                              the SAME TIME. This step puts all three DLLs in
                                                              SW reset (RLDCK, RLDCK90, RLDQK90 DLLs).
                                                           3) Write a '0' into the DFA_MEM_CFG0[RLDCK_RST] field.
                                                              This step takes the RLDCK DLL out of soft-reset so
                                                              that the DLL can generate the RLDx_CK_H/L clock pins.
                                                           4) Wait 1ms (for RLDCK DLL to achieve lock)
                                                           5) Write a '0' into DFA_MEM_CFG0[RLDQCK90_RST] field.
                                                              This step takes the RLDCK90 DLL AND RLDQK90 DLL out
                                                              of soft-reset.
                                                           6) Wait 1ms (for RLDCK90/RLDQK90 DLLs to achieve lock)
                                                           7) Enable memory port(s) ENA_P0=1/ENA_P1=1
                                                           8) Wait 100us (to ensure a stable clock
                                                              to the RLDRAMs) - as per RLDRAM spec.
                                                           - - - - - Hardware Initialization Sequence - - - - -
                                                           9) Setup the DFA_MEMCFG0[BUNK_INIT] for the bunk(s)
                                                              intended to be initialized.
                                                          10) Write a '1' to the corresponding INIT_Px which
                                                              will initiate a hardware initialization
                                                              sequence to that'specific' port.
                                                          11) Wait (DFA_MEMCFG0[CLKDIV] * 32K) eclk cycles.
                                                              [to ensure the HW init sequence has completed
                                                              before writing to ANY of the DFA_MEM* registers]
                                                           - - - - - Hardware Initialization Sequence - - - - -
                                                          12) Write the DFA_MEMCFG0[BUNK_INIT]=3 to enable
                                                              refreshes to BOTH bunks.
                                                         NOTE: In some cases (where the address wires are routed
                                                         differently between the front and back 'bunks'),
                                                         SW will need to use DFA_MEMCFG0[BUNK_INIT] bits to
                                                         control the Hardware initialization sequence for a
                                                         'specific bunk'. In these cases, SW would setup the
                                                         BUNK_INIT and repeat Steps \#9-11 for each bunk/port.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: DFA Memory Port#1 corresponds to the Octeon
                                                         RLD1_* pins. */
	uint64_t r2r_pbunk                    : 1;  /**< When enabled, an additional command bubble is inserted
                                                         if back to back reads are issued to different physical
                                                         bunks. This is to avoid DQ data bus collisions when
                                                         references cross between physical bunks.
                                                         [NOTE: the physical bunk address boundary is determined
                                                         by the PBUNK bit].
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t pbunk                        : 3;  /**< Physical Bunk address bit pointer.
                                                         Specifies which address bit within the Longword
                                                         Memory address MA[23:0] is used to determine the
                                                         chip selects.
                                                         [RLD_CS0_N corresponds to physical bunk \#0, and
                                                         RLD_CS1_N corresponds to physical bunk \#1].
                                                           - 000: CS0_N = MA[19]/CS1_N = !MA[19]
                                                           - 001: CS0_N = MA[20]/CS1_N = !MA[20]
                                                           - 010: CS0_N = MA[21]/CS1_N = !MA[21]
                                                           - 011: CS0_N = MA[22]/CS1_N = !MA[22]
                                                           - 100: CS0_N = MA[23]/CS1_N = !MA[23]
                                                           - 101-111: CS0_N = 0 /CS1_N = 1
                                                         Example(s):
                                                         To build out a 128MB DFA memory, 4x 32Mx9
                                                         parts could be used to fill out TWO physical
                                                         bunks (clamshell configuration). Each (of the
                                                         two) physical bunks contains 2x 32Mx9 = 16Mx36.
                                                         Each RLDRAM device also contains 8 internal banks,
                                                         therefore the memory Address is 16M/8banks = 2M
                                                         addresses/bunk (2^21). In this case, MA[21] would
                                                         select the physical bunk.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         be used to determine the Chip Select(s). */
	uint64_t blen                         : 1;  /**< Device Burst Length  (0=2-burst/1=4-burst)
                                                         NOTE: RLDRAM-II MUST USE BLEN=0(2-burst) */
	uint64_t bprch                        : 2;  /**< Tristate Enable (back porch) (\#dclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable back porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t fprch                        : 2;  /**< Tristate Enable (front porch) (\#dclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable front porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t wr_dly                       : 4;  /**< Write->Read CMD Delay (\#mclks):
                                                         Determines \#mclk cycles to insert when controller
                                                         switches from write to read. This allows programmer
                                                         to control the data bus contention.
                                                         For RLDRAM-II(BL2): (TBL=1)
                                                         WR_DLY = ROUND_UP[((TWL+TBL)*2 - TSKW + FPRCH) / 2] - TRL + 1
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For aggressive(performance optimal) designs,
                                                         the WR_DLY 'may' be tuned down(-1) if bus fight
                                                         on W->R transitions is not pronounced. */
	uint64_t rw_dly                       : 4;  /**< Read->Write CMD Delay (\#mclks):
                                                         Determines \#mclk cycles to insert when controller
                                                         switches from read to write. This allows programmer
                                                         to control the data bus contention.
                                                         For RLDRAM-II(BL2): (TBL=1)
                                                         RW_DLY = ROUND_UP[((TRL+TBL)*2 + TSKW + BPRCH+2)/2] - TWL + 1
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For aggressive(performance optimal) designs,
                                                         the RW_DLY 'may' be tuned down(-1) if bus fight
                                                         on R->W transitions is not pronounced. */
	uint64_t sil_lat                      : 2;  /**< Silo Latency (\#dclks): On reads, determines how many
                                                         additional dclks to wait (on top of tRL+1) before
                                                         pulling data out of the padring silos used for time
                                                         domain boundary crossing.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t mtype                        : 1;  /**< FCRAM-II Memory Type
                                                         *** CN58XX UNSUPPORTED *** */
	uint64_t reserved_2_2                 : 1;
	uint64_t ena_p0                       : 1;  /**< Enable DFA RLDRAM Port#0
                                                         When enabled, this bit lets N3K be the default
                                                         driver for memory port \#0.
                                                         NOTE: a customer is at
                                                         liberty to enable either Port#0 or Port#1 or both.
                                                         NOTE: Once a port has been disabled, it MUST NEVER
                                                         be re-enabled. [the only way to enable a port is
                                                         through a chip reset].
                                                         NOTE: DFA Memory Port#0 corresponds to the Octeon
                                                         RLD0_* pins. */
	uint64_t ena_p1                       : 1;  /**< Enable DFA RLDRAM Port#1
                                                         When enabled, this bit lets N3K be the default
                                                         driver for memory port \#1.
                                                         NOTE: a customer is at
                                                         liberty to enable either Port#0 or Port#1 or both.
                                                         NOTE: Once a port has been disabled, it MUST NEVER
                                                         be re-enabled. [the only way to enable a port is
                                                         through a chip reset].
                                                         NOTE: DFA Memory Port#1 corresponds to the Octeon
                                                         RLD1_* pins. */
#else
	uint64_t ena_p1                       : 1;
	uint64_t ena_p0                       : 1;
	uint64_t reserved_2_2                 : 1;
	uint64_t mtype                        : 1;
	uint64_t sil_lat                      : 2;
	uint64_t rw_dly                       : 4;
	uint64_t wr_dly                       : 4;
	uint64_t fprch                        : 2;
	uint64_t bprch                        : 2;
	uint64_t blen                         : 1;
	uint64_t pbunk                        : 3;
	uint64_t r2r_pbunk                    : 1;
	uint64_t init_p1                      : 1;
	uint64_t init_p0                      : 1;
	uint64_t bunk_init                    : 2;
	uint64_t lpp_ena                      : 1;
	uint64_t clkdiv                       : 2;
	uint64_t rldck_rst                    : 1;
	uint64_t rldqck90_rst                 : 1;
	uint64_t reserved_32_63               : 32;
#endif
	} s;
	struct cvmx_dfa_memcfg0_cn38xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_28_63               : 36;
	uint64_t lpp_ena                      : 1;  /**< PP Linear Port Addressing Mode Enable
                                                         When enabled, PP-core LLM accesses to the lower-512MB
                                                         LLM address space are sent to the single DFA port
                                                         which is enabled. NOTE: If LPP_ENA=1, only
                                                         one DFA RLDRAM port may be enabled for RLDRAM accesses
                                                         (ie: ENA_P0 and ENA_P1 CAN NEVER BOTH be set).
                                                         PP-core LLM accesses to the upper-512MB LLM address
                                                         space are sent to the other 'disabled' DFA port.
                                                         SW RESTRICTION: If LPP_ENA=1, then only one DFA port
                                                         may be enabled for RLDRAM accesses (ie: ENA_P0 and
                                                         ENA_P1 CAN NEVER BOTH be set).
                                                         NOTE: This bit is used to allow PP-Core LLM accesses to a
                                                         disabled port, such that each port can be sequentially
                                                         addressed (ie: disable LW address interleaving).
                                                         Enabling this bit allows BOTH PORTs to be active and
                                                         sequentially addressable. The single port that is
                                                         enabled(ENA_Px) will respond to the low-512MB LLM address
                                                         space, and the other 'disabled' port will respond to the
                                                         high-512MB LLM address space.
                                                         Example usage:
                                                            - DFA RLD0 pins used for TCAM-FPGA(CP2 accesses)
                                                            - DFA RLD1 pins used for RLDRAM (DTE/CP2 accesses).
                                                         USAGE NOTE:
                                                         If LPP_ENA=1 and SW DOES NOT initialize the disabled port
                                                         (ie: INIT_Px=0->1), then refreshes and the HW init
                                                         sequence WILL NOT occur for the disabled port.
                                                         If LPP_ENA=1 and SW does initialize the disabled port
                                                         (INIT_Px=0->1 with ENA_Px=0), then refreshes and
                                                         the HW init sequence WILL occur to the disabled port. */
	uint64_t bunk_init                    : 2;  /**< Controls the CS_N[1:0] during a) a HW Initialization
                                                         sequence (triggered by DFA_MEMCFG0[INIT_Px]) or
                                                         b) during a normal refresh sequence. If
                                                         the BNK_INIT[x]=1, the corresponding CS_N[x] is driven.
                                                         NOTE: This is required for DRAM used in a
                                                         clamshell configuration, since the address lines
                                                         carry Mode Register write data that is unique
                                                         per bunk(or clam). In a clamshell configuration,
                                                         The N3K A[x] pin may be tied into Clam#0's A[x]
                                                         and also into Clam#1's 'mirrored' address bit A[y]
                                                         (eg: Clam0 sees A[5] and Clam1 sees A[15]).
                                                         To support clamshell designs, SW must initiate
                                                         two separate HW init sequences for the two bunks
                                                         (or clams) . Before each HW init sequence is triggered,
                                                         SW must preload the DFA_MEMRLD[22:0] with the data
                                                         that will be driven onto the A[22:0] wires during
                                                         an MRS mode register write.
                                                         NOTE: After the final HW initialization sequence has
                                                         been triggered, SW must wait 64K eclks before writing
                                                         the BUNK_INIT[1:0] field = 3'b11 (so that CS_N[1:0] is
                                                         driven during refresh sequences in normal operation.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For MTYPE=1(FCRAM) Mode, each bunk MUST BE
                                                         initialized independently. In other words, a HW init
                                                         must be done for Bunk#0, and then another HW init
                                                         must be done for Bunk#1 at power-on. */
	uint64_t init_p0                      : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for Memory Port \#0 is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Enable memory port(s):
                                                               a) ENA_P1=1 (single port in pass 1) OR
                                                               b) ENA_P0=1/ENA_P1=1 (dual ports or single when not pass 1)
                                                           2) Wait 100us (to ensure a stable clock
                                                              to the RLDRAMs) - as per RLDRAM spec.
                                                           3) Write a '1' to the corresponding INIT_Px which
                                                              will initiate a hardware initialization
                                                              sequence.
                                                         NOTE: After writing a '1', SW must wait 64K eclk
                                                         cycles to ensure the HW init sequence has completed
                                                         before writing to ANY of the DFA_MEM* registers.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: DFA Memory Port#0 corresponds to the Octeon
                                                         RLD0_* pins. */
	uint64_t init_p1                      : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for Memory Port \#1 is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Enable memory port(s):
                                                               a) ENA_P1=1 (single port in pass 1) OR
                                                               b) ENA_P0=1/ENA_P1=1 (dual ports or single when not pass 1)
                                                           2) Wait 100us (to ensure a stable clock
                                                              to the RLDRAMs) - as per RLDRAM spec.
                                                           3) Write a '1' to the corresponding INIT_Px which
                                                              will initiate a hardware initialization
                                                              sequence.
                                                         NOTE: After writing a '1', SW must wait 64K eclk
                                                         cycles to ensure the HW init sequence has completed
                                                         before writing to ANY of the DFA_MEM* registers.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: DFA Memory Port#1 corresponds to the Octeon
                                                         RLD1_* pins. */
	uint64_t r2r_pbunk                    : 1;  /**< When enabled, an additional command bubble is inserted
                                                         if back to back reads are issued to different physical
                                                         bunks. This is to avoid DQ data bus collisions when
                                                         references cross between physical bunks.
                                                         [NOTE: the physical bunk address boundary is determined
                                                         by the PBUNK bit].
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         When MTYPE=1(FCRAM)/BLEN=0(2-burst), R2R_PBUNK SHOULD BE
                                                         ZERO(for optimal performance). However, if electrically,
                                                         DQ-sharing becomes a power/heat issue, then R2R_PBUNK
                                                         should be set (but at a cost to performance (1/2 BW). */
	uint64_t pbunk                        : 3;  /**< Physical Bunk address bit pointer.
                                                         Specifies which address bit within the Longword
                                                         Memory address MA[23:0] is used to determine the
                                                         chip selects.
                                                         [RLD_CS0_N corresponds to physical bunk \#0, and
                                                         RLD_CS1_N corresponds to physical bunk \#1].
                                                           - 000: CS0_N = MA[19]/CS1_N = !MA[19]
                                                           - 001: CS0_N = MA[20]/CS1_N = !MA[20]
                                                           - 010: CS0_N = MA[21]/CS1_N = !MA[21]
                                                           - 011: CS0_N = MA[22]/CS1_N = !MA[22]
                                                           - 100: CS0_N = MA[23]/CS1_N = !MA[23]
                                                           - 101-111: CS0_N = 0 /CS1_N = 1
                                                         Example(s):
                                                         To build out a 128MB DFA memory, 4x 32Mx9
                                                         parts could be used to fill out TWO physical
                                                         bunks (clamshell configuration). Each (of the
                                                         two) physical bunks contains 2x 32Mx9 = 16Mx36.
                                                         Each RLDRAM device also contains 8 internal banks,
                                                         therefore the memory Address is 16M/8banks = 2M
                                                         addresses/bunk (2^21). In this case, MA[21] would
                                                         select the physical bunk.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         be used to determine the Chip Select(s).
                                                         NOTE: When MTYPE=1(FCRAM)/BLEN=0(2-burst), a
                                                         "Redundant Bunk" scheme is employed to provide the
                                                         highest overall performance (1 Req/ MCLK cycle).
                                                         In this mode, it's imperative that SW set the PBUNK
                                                         field +1 'above' the highest address bit. (such that
                                                         the PBUNK extracted from the address will always be
                                                         zero). In this mode, the CS_N[1:0] pins are driven
                                                         to each redundant bunk based on a TDM scheme:
                                                         [MCLK-EVEN=Bunk#0/MCLK-ODD=Bunk#1]. */
	uint64_t blen                         : 1;  /**< Device Burst Length  (0=2-burst/1=4-burst)
                                                         When BLEN=0(BL2), all QW reads/writes from CP2 are
                                                         decomposed into 2 separate BL2(LW) requests to the
                                                         Low-Latency memory.
                                                         When BLEN=1(BL4), a LW request (from CP2 or NCB) is
                                                         treated as 1 BL4(QW) request to the low latency memory.
                                                         NOTE: QW refers to a 64-bit LLM Load/Store (intiated
                                                         by a processor core). LW refers to a 36-bit load/store.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization before the DFA LLM
                                                         (low latency memory) is used.
                                                         NOTE: MTYPE=0(RLDRAM-II) MUST USE BLEN=0(2-burst)
                                                         NOTE: MTYPE=1(FCRAM)/BLEN=0(BL2) requires a
                                                         multi-bunk(clam) board design.
                                                         NOTE: If MTYPE=1(FCRAM)/FCRAM2P=0(II)/BLEN=1(BL4),
                                                         SW SHOULD use CP2 QW read/write requests (for
                                                         optimal low-latency bus performance).
                                                         [LW length read/write requests(in BL4 mode) use 50%
                                                         of the available bus bandwidth]
                                                         NOTE: MTYPE=1(FCRAM)/FCRAM2P=0(II)/BLEN=0(BL2) can only
                                                         be used with FCRAM-II devices which support BL2 mode
                                                         (see: Toshiba FCRAM-II, where DQ tristate after 2 data
                                                         transfers).
                                                         NOTE: MTYPE=1(FCRAM)/FCRAM2P=1(II+) does not support LW
                                                         write requests (FCRAM-II+ device specification has removed
                                                         the variable write mask function from the devices).
                                                         As such, if this mode is used, SW must be careful to
                                                         issue only PP-CP2 QW write requests. */
	uint64_t bprch                        : 2;  /**< Tristate Enable (back porch) (\#dclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable back porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t fprch                        : 2;  /**< Tristate Enable (front porch) (\#dclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable front porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t wr_dly                       : 4;  /**< Write->Read CMD Delay (\#mclks):
                                                         Determines \#mclk cycles to insert when controller
                                                         switches from write to read. This allows programmer
                                                         to control the data bus contention.
                                                         For RLDRAM-II(BL2): (TBL=1)
                                                         For FCRAM-II (BL4): (TBL=2)
                                                         For FCRAM-II (BL2 grepl=1x ONLY): (TBL=1)
                                                         For FCRAM-II (BL2 grepl>=2x): (TBL=3)
                                                            NOTE: When MTYTPE=1(FCRAM-II) BLEN=0(BL2 Mode),
                                                            grepl>=2x, writes require redundant bunk writes
                                                            which require an additional 2 cycles before slotting
                                                            the next read.
                                                         WR_DLY = ROUND_UP[((TWL+TBL)*2 - TSKW + FPRCH) / 2] - TRL + 1
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For aggressive(performance optimal) designs,
                                                         the WR_DLY 'may' be tuned down(-1) if bus fight
                                                         on W->R transitions is not pronounced. */
	uint64_t rw_dly                       : 4;  /**< Read->Write CMD Delay (\#mclks):
                                                         Determines \#mclk cycles to insert when controller
                                                         switches from read to write. This allows programmer
                                                         to control the data bus contention.
                                                         For RLDRAM-II/FCRAM-II (BL2): (TBL=1)
                                                         For FCRAM-II (BL4): (TBL=2)
                                                         RW_DLY = ROUND_UP[((TRL+TBL)*2 + TSKW + BPRCH+2)/2] - TWL + 1
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For aggressive(performance optimal) designs,
                                                         the RW_DLY 'may' be tuned down(-1) if bus fight
                                                         on R->W transitions is not pronounced. */
	uint64_t sil_lat                      : 2;  /**< Silo Latency (\#dclks): On reads, determines how many
                                                         additional dclks to wait (on top of tRL+1) before
                                                         pulling data out of the padring silos used for time
                                                         domain boundary crossing.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t mtype                        : 1;  /**< Memory Type (0=RLDRAM-II/1=Network DRAM-II/FCRAM)
                                                         NOTE: N3K-P1 only supports RLDRAM-II
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: When MTYPE=1(FCRAM)/BLEN=0(2-burst), only the
                                                         "unidirectional DS/QS" mode is supported. (see FCRAM
                                                         data sheet EMRS[A6:A5]=SS(Strobe Select) register
                                                         definition. [in FCRAM 2-burst mode, we use FCRAM
                                                         in a clamshell configuration such that clam0 is
                                                         addressed independently of clam1, and DQ is shared
                                                         for optimal performance. As such it's imperative that
                                                         the QS are conditionally received (and are NOT
                                                         free-running), as the N3K receive data capture silos
                                                         OR the clam0/1 QS strobes.
                                                         NOTE: If this bit is SET, the ASX0/1
                                                         ASX_RLD_FCRAM_MODE[MODE] bit(s) should also be SET
                                                         in order for the RLD0/1-PHY(s) to support FCRAM devices. */
	uint64_t reserved_2_2                 : 1;
	uint64_t ena_p0                       : 1;  /**< Enable DFA RLDRAM Port#0
                                                         When enabled, this bit lets N3K be the default
                                                         driver for memory port \#0.
                                                         NOTE: For N3K-P1, to enable Port#0(2nd port),
                                                         Port#1 MUST ALSO be enabled.
                                                         NOTE: For N3K-P2, single port mode, a customer is at
                                                         liberty to enable either Port#0 or Port#1.
                                                         NOTE: Once a port has been disabled, it MUST NEVER
                                                         be re-enabled. [the only way to enable a port is
                                                         through a chip reset].
                                                         NOTE: DFA Memory Port#0 corresponds to the Octeon
                                                         RLD0_* pins. */
	uint64_t ena_p1                       : 1;  /**< Enable DFA RLDRAM Port#1
                                                         When enabled, this bit lets N3K be the default
                                                         driver for memory port \#1.
                                                         NOTE: For N3K-P1, If the customer wishes to use a
                                                         single port, s/he must enable Port#1 (and not Port#0).
                                                         NOTE: For N3K-P2, single port mode, a customer is at
                                                         liberty to enable either Port#0 or Port#1.
                                                         NOTE: Once a port has been disabled, it MUST NEVER
                                                         be re-enabled. [the only way to enable a port is
                                                         through a chip reset].
                                                         NOTE: DFA Memory Port#1 corresponds to the Octeon
                                                         RLD1_* pins. */
#else
	uint64_t ena_p1                       : 1;
	uint64_t ena_p0                       : 1;
	uint64_t reserved_2_2                 : 1;
	uint64_t mtype                        : 1;
	uint64_t sil_lat                      : 2;
	uint64_t rw_dly                       : 4;
	uint64_t wr_dly                       : 4;
	uint64_t fprch                        : 2;
	uint64_t bprch                        : 2;
	uint64_t blen                         : 1;
	uint64_t pbunk                        : 3;
	uint64_t r2r_pbunk                    : 1;
	uint64_t init_p1                      : 1;
	uint64_t init_p0                      : 1;
	uint64_t bunk_init                    : 2;
	uint64_t lpp_ena                      : 1;
	uint64_t reserved_28_63               : 36;
#endif
	} cn38xx;
	struct cvmx_dfa_memcfg0_cn38xxp2
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_27_63               : 37;
	uint64_t bunk_init                    : 2;  /**< Controls the CS_N[1:0] during a) a HW Initialization
                                                         sequence (triggered by DFA_MEMCFG0[INIT_Px]) or
                                                         b) during a normal refresh sequence. If
                                                         the BNK_INIT[x]=1, the corresponding CS_N[x] is driven.
                                                         NOTE: This is required for DRAM used in a
                                                         clamshell configuration, since the address lines
                                                         carry Mode Register write data that is unique
                                                         per bunk(or clam). In a clamshell configuration,
                                                         The N3K A[x] pin may be tied into Clam#0's A[x]
                                                         and also into Clam#1's 'mirrored' address bit A[y]
                                                         (eg: Clam0 sees A[5] and Clam1 sees A[15]).
                                                         To support clamshell designs, SW must initiate
                                                         two separate HW init sequences for the two bunks
                                                         (or clams) . Before each HW init sequence is triggered,
                                                         SW must preload the DFA_MEMRLD[22:0] with the data
                                                         that will be driven onto the A[22:0] wires during
                                                         an MRS mode register write.
                                                         NOTE: After the final HW initialization sequence has
                                                         been triggered, SW must wait 64K eclks before writing
                                                         the BUNK_INIT[1:0] field = 3'b11 (so that CS_N[1:0] is
                                                         driven during refresh sequences in normal operation.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For MTYPE=1(FCRAM) Mode, each bunk MUST BE
                                                         initialized independently. In other words, a HW init
                                                         must be done for Bunk#0, and then another HW init
                                                         must be done for Bunk#1 at power-on. */
	uint64_t init_p0                      : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for Memory Port \#0 is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Enable memory port(s):
                                                               a) ENA_P1=1 (single port in pass 1) OR
                                                               b) ENA_P0=1/ENA_P1=1 (dual ports or single when not pass 1)
                                                           2) Wait 100us (to ensure a stable clock
                                                              to the RLDRAMs) - as per RLDRAM spec.
                                                           3) Write a '1' to the corresponding INIT_Px which
                                                              will initiate a hardware initialization
                                                              sequence.
                                                         NOTE: After writing a '1', SW must wait 64K eclk
                                                         cycles to ensure the HW init sequence has completed
                                                         before writing to ANY of the DFA_MEM* registers.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: DFA Memory Port#0 corresponds to the Octeon
                                                         RLD0_* pins. */
	uint64_t init_p1                      : 1;  /**< When a '1' is written (and the previous value was '0'),
                                                         the HW init sequence(s) for Memory Port \#1 is
                                                         initiated.
                                                         NOTE: To initialize memory, SW must:
                                                           1) Enable memory port(s):
                                                               a) ENA_P1=1 (single port in pass 1) OR
                                                               b) ENA_P0=1/ENA_P1=1 (dual ports or single when not pass 1)
                                                           2) Wait 100us (to ensure a stable clock
                                                              to the RLDRAMs) - as per RLDRAM spec.
                                                           3) Write a '1' to the corresponding INIT_Px which
                                                              will initiate a hardware initialization
                                                              sequence.
                                                         NOTE: After writing a '1', SW must wait 64K eclk
                                                         cycles to ensure the HW init sequence has completed
                                                         before writing to ANY of the DFA_MEM* registers.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: DFA Memory Port#1 corresponds to the Octeon
                                                         RLD1_* pins. */
	uint64_t r2r_pbunk                    : 1;  /**< When enabled, an additional command bubble is inserted
                                                         if back to back reads are issued to different physical
                                                         bunks. This is to avoid DQ data bus collisions when
                                                         references cross between physical bunks.
                                                         [NOTE: the physical bunk address boundary is determined
                                                         by the PBUNK bit].
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         When MTYPE=1(FCRAM)/BLEN=0(2-burst), R2R_PBUNK SHOULD BE
                                                         ZERO(for optimal performance). However, if electrically,
                                                         DQ-sharing becomes a power/heat issue, then R2R_PBUNK
                                                         should be set (but at a cost to performance (1/2 BW). */
	uint64_t pbunk                        : 3;  /**< Physical Bunk address bit pointer.
                                                         Specifies which address bit within the Longword
                                                         Memory address MA[23:0] is used to determine the
                                                         chip selects.
                                                         [RLD_CS0_N corresponds to physical bunk \#0, and
                                                         RLD_CS1_N corresponds to physical bunk \#1].
                                                           - 000: CS0_N = MA[19]/CS1_N = !MA[19]
                                                           - 001: CS0_N = MA[20]/CS1_N = !MA[20]
                                                           - 010: CS0_N = MA[21]/CS1_N = !MA[21]
                                                           - 011: CS0_N = MA[22]/CS1_N = !MA[22]
                                                           - 100: CS0_N = MA[23]/CS1_N = !MA[23]
                                                           - 101-111: CS0_N = 0 /CS1_N = 1
                                                         Example(s):
                                                         To build out a 128MB DFA memory, 4x 32Mx9
                                                         parts could be used to fill out TWO physical
                                                         bunks (clamshell configuration). Each (of the
                                                         two) physical bunks contains 2x 32Mx9 = 16Mx36.
                                                         Each RLDRAM device also contains 8 internal banks,
                                                         therefore the memory Address is 16M/8banks = 2M
                                                         addresses/bunk (2^21). In this case, MA[21] would
                                                         select the physical bunk.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         be used to determine the Chip Select(s).
                                                         NOTE: When MTYPE=1(FCRAM)/BLEN=0(2-burst), a
                                                         "Redundant Bunk" scheme is employed to provide the
                                                         highest overall performance (1 Req/ MCLK cycle).
                                                         In this mode, it's imperative that SW set the PBUNK
                                                         field +1 'above' the highest address bit. (such that
                                                         the PBUNK extracted from the address will always be
                                                         zero). In this mode, the CS_N[1:0] pins are driven
                                                         to each redundant bunk based on a TDM scheme:
                                                         [MCLK-EVEN=Bunk#0/MCLK-ODD=Bunk#1]. */
	uint64_t blen                         : 1;  /**< Device Burst Length  (0=2-burst/1=4-burst)
                                                         When BLEN=0(BL2), all QW reads/writes from CP2 are
                                                         decomposed into 2 separate BL2(LW) requests to the
                                                         Low-Latency memory.
                                                         When BLEN=1(BL4), a LW request (from CP2 or NCB) is
                                                         treated as 1 BL4(QW) request to the low latency memory.
                                                         NOTE: QW refers to a 64-bit LLM Load/Store (intiated
                                                         by a processor core). LW refers to a 36-bit load/store.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization before the DFA LLM
                                                         (low latency memory) is used.
                                                         NOTE: MTYPE=0(RLDRAM-II) MUST USE BLEN=0(2-burst)
                                                         NOTE: MTYPE=1(FCRAM)/BLEN=0(BL2) requires a
                                                         multi-bunk(clam) board design.
                                                         NOTE: If MTYPE=1(FCRAM)/FCRAM2P=0(II)/BLEN=1(BL4),
                                                         SW SHOULD use CP2 QW read/write requests (for
                                                         optimal low-latency bus performance).
                                                         [LW length read/write requests(in BL4 mode) use 50%
                                                         of the available bus bandwidth]
                                                         NOTE: MTYPE=1(FCRAM)/FCRAM2P=0(II)/BLEN=0(BL2) can only
                                                         be used with FCRAM-II devices which support BL2 mode
                                                         (see: Toshiba FCRAM-II, where DQ tristate after 2 data
                                                         transfers).
                                                         NOTE: MTYPE=1(FCRAM)/FCRAM2P=1(II+) does not support LW
                                                         write requests (FCRAM-II+ device specification has removed
                                                         the variable write mask function from the devices).
                                                         As such, if this mode is used, SW must be careful to
                                                         issue only PP-CP2 QW write requests. */
	uint64_t bprch                        : 2;  /**< Tristate Enable (back porch) (\#dclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable back porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t fprch                        : 2;  /**< Tristate Enable (front porch) (\#dclks)
                                                         On reads, allows user to control the shape of the
                                                         tristate disable front porch for the DQ data bus.
                                                         This parameter is also very dependent on the
                                                         RW_DLY and WR_DLY parameters and care must be
                                                         taken when programming these parameters to avoid
                                                         data bus contention. Valid range [0..2]
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t wr_dly                       : 4;  /**< Write->Read CMD Delay (\#mclks):
                                                         Determines \#mclk cycles to insert when controller
                                                         switches from write to read. This allows programmer
                                                         to control the data bus contention.
                                                         For RLDRAM-II(BL2): (TBL=1)
                                                         For FCRAM-II (BL4): (TBL=2)
                                                         For FCRAM-II (BL2 grepl=1x ONLY): (TBL=1)
                                                         For FCRAM-II (BL2 grepl>=2x): (TBL=3)
                                                            NOTE: When MTYTPE=1(FCRAM-II) BLEN=0(BL2 Mode),
                                                            grepl>=2x, writes require redundant bunk writes
                                                            which require an additional 2 cycles before slotting
                                                            the next read.
                                                         WR_DLY = ROUND_UP[((TWL+TBL)*2 - TSKW + FPRCH) / 2] - TRL + 1
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For aggressive(performance optimal) designs,
                                                         the WR_DLY 'may' be tuned down(-1) if bus fight
                                                         on W->R transitions is not pronounced. */
	uint64_t rw_dly                       : 4;  /**< Read->Write CMD Delay (\#mclks):
                                                         Determines \#mclk cycles to insert when controller
                                                         switches from read to write. This allows programmer
                                                         to control the data bus contention.
                                                         For RLDRAM-II/FCRAM-II (BL2): (TBL=1)
                                                         For FCRAM-II (BL4): (TBL=2)
                                                         RW_DLY = ROUND_UP[((TRL+TBL)*2 + TSKW + BPRCH+2)/2] - TWL + 1
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: For aggressive(performance optimal) designs,
                                                         the RW_DLY 'may' be tuned down(-1) if bus fight
                                                         on R->W transitions is not pronounced. */
	uint64_t sil_lat                      : 2;  /**< Silo Latency (\#dclks): On reads, determines how many
                                                         additional dclks to wait (on top of tRL+1) before
                                                         pulling data out of the padring silos used for time
                                                         domain boundary crossing.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t mtype                        : 1;  /**< Memory Type (0=RLDRAM-II/1=Network DRAM-II/FCRAM)
                                                         NOTE: N3K-P1 only supports RLDRAM-II
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: When MTYPE=1(FCRAM)/BLEN=0(2-burst), only the
                                                         "unidirectional DS/QS" mode is supported. (see FCRAM
                                                         data sheet EMRS[A6:A5]=SS(Strobe Select) register
                                                         definition. [in FCRAM 2-burst mode, we use FCRAM
                                                         in a clamshell configuration such that clam0 is
                                                         addressed independently of clam1, and DQ is shared
                                                         for optimal performance. As such it's imperative that
                                                         the QS are conditionally received (and are NOT
                                                         free-running), as the N3K receive data capture silos
                                                         OR the clam0/1 QS strobes.
                                                         NOTE: If this bit is SET, the ASX0/1
                                                         ASX_RLD_FCRAM_MODE[MODE] bit(s) should also be SET
                                                         in order for the RLD0/1-PHY(s) to support FCRAM devices. */
	uint64_t reserved_2_2                 : 1;
	uint64_t ena_p0                       : 1;  /**< Enable DFA RLDRAM Port#0
                                                         When enabled, this bit lets N3K be the default
                                                         driver for memory port \#0.
                                                         NOTE: For N3K-P1, to enable Port#0(2nd port),
                                                         Port#1 MUST ALSO be enabled.
                                                         NOTE: For N3K-P2, single port mode, a customer is at
                                                         liberty to enable either Port#0 or Port#1.
                                                         NOTE: Once a port has been disabled, it MUST NEVER
                                                         be re-enabled. [the only way to enable a port is
                                                         through a chip reset].
                                                         NOTE: DFA Memory Port#0 corresponds to the Octeon
                                                         RLD0_* pins. */
	uint64_t ena_p1                       : 1;  /**< Enable DFA RLDRAM Port#1
                                                         When enabled, this bit lets N3K be the default
                                                         driver for memory port \#1.
                                                         NOTE: For N3K-P1, If the customer wishes to use a
                                                         single port, s/he must enable Port#1 (and not Port#0).
                                                         NOTE: For N3K-P2, single port mode, a customer is at
                                                         liberty to enable either Port#0 or Port#1.
                                                         NOTE: Once a port has been disabled, it MUST NEVER
                                                         be re-enabled. [the only way to enable a port is
                                                         through a chip reset].
                                                         NOTE: DFA Memory Port#1 corresponds to the Octeon
                                                         RLD1_* pins. */
#else
	uint64_t ena_p1                       : 1;
	uint64_t ena_p0                       : 1;
	uint64_t reserved_2_2                 : 1;
	uint64_t mtype                        : 1;
	uint64_t sil_lat                      : 2;
	uint64_t rw_dly                       : 4;
	uint64_t wr_dly                       : 4;
	uint64_t fprch                        : 2;
	uint64_t bprch                        : 2;
	uint64_t blen                         : 1;
	uint64_t pbunk                        : 3;
	uint64_t r2r_pbunk                    : 1;
	uint64_t init_p1                      : 1;
	uint64_t init_p0                      : 1;
	uint64_t bunk_init                    : 2;
	uint64_t reserved_27_63               : 37;
#endif
	} cn38xxp2;
	struct cvmx_dfa_memcfg0_s             cn58xx;
	struct cvmx_dfa_memcfg0_s             cn58xxp1;
};
typedef union cvmx_dfa_memcfg0 cvmx_dfa_memcfg0_t;

/**
 * cvmx_dfa_memcfg1
 *
 * DFA_MEMCFG1 = RLDRAM Memory Timing Configuration
 *
 * Description:
 */
union cvmx_dfa_memcfg1
{
	uint64_t u64;
	struct cvmx_dfa_memcfg1_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_34_63               : 30;
	uint64_t ref_intlo                    : 9;  /**< Burst Refresh Interval[8:0] (\#dclks)
                                                         For finer refresh interval granularity control.
                                                         This field provides an additional level of granularity
                                                         for the refresh interval. It specifies the additional
                                                         \#dclks [0...511] to be added to the REF_INT[3:0] field.
                                                         For RLDRAM-II: For dclk(400MHz=2.5ns):
                                                         Example: 64K AREF cycles required within tREF=32ms
                                                             trefint = tREF(ms)/(64K cycles/8banks)
                                                                         = 32ms/8K = 3.9us = 3900ns
                                                             REF_INT[3:0] = ROUND_DOWN[(trefint/dclk)/512]
                                                                          = ROUND_DOWN[(3900/2.5)/512]
                                                                          = 3
                                                             REF_INTLO[8:0] = MOD[(trefint/dclk)/512]
                                                                            = MOD[(3900/2.5)/512]
                                                                            = 24
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t aref_ena                     : 1;  /**< Auto Refresh Cycle Enable
                                                         INTERNAL USE ONLY:
                                                         NOTE: This mode bit is ONLY intended to be used by
                                                         low-level power-on initialization routines in the
                                                         event that the hardware initialization routine
                                                         does not work. It allows SW to create AREF
                                                         commands on the RLDRAM bus directly.
                                                         When this bit is set, ALL RLDRAM writes (issued by
                                                         a PP through the NCB or CP2) are converted to AREF
                                                         commands on the RLDRAM bus. The write-address is
                                                         presented on the A[20:0]/BA[2:0] pins (for which
                                                         the RLDRAM only interprets BA[2:0]).
                                                         When this bit is set, only writes are allowed
                                                         and MUST use grepl=0 (1x).
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: MRS_ENA and AREF_ENA are mutually exclusive
                                                         (SW can set one or the other, but never both!)
                                                         NOTE: AREF commands generated using this method target
                                                         the 'addressed' bunk. */
	uint64_t mrs_ena                      : 1;  /**< Mode Register Set Cycle Enable
                                                         INTERNAL USE ONLY:
                                                         NOTE: This mode bit is ONLY intended to be used by
                                                         low-level power-on initialization routines in the
                                                         event that the hardware initialization routine
                                                         does not work. It allows SW to create MRS
                                                         commands on the RLDRAM bus directly.
                                                         When this bit is set, ALL RLDRAM writes (issued by
                                                         a PP through the NCB or CP2) are converted to MRS
                                                         commands on the RLDRAM bus. The write-address is
                                                         presented on the A[20:0]/BA[2:0] pins (for which
                                                         the RLDRAM only interprets A[17:0]).
                                                         When this bit is set, only writes are allowed
                                                         and MUST use grepl=0 (1x).
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization.
                                                         NOTE: MRS_ENA and AREF_ENA are mutually exclusive
                                                         (SW can set one or the other, but never both!)
                                                         NOTE: MRS commands generated using this method target
                                                         the 'addressed' bunk. */
	uint64_t tmrsc                        : 3;  /**< Mode Register Set Cycle Time (represented in \#mclks)
                                                              - 000-001: RESERVED
                                                              - 010: tMRSC = 2 mclks
                                                              - 011: tMRSC = 3 mclks
                                                              - ...
                                                              - 111: tMRSC = 7 mclks
                                                         NOTE: The device tMRSC parameter is a function of CL
                                                         (which during HW initialization is not known. Its
                                                         recommended to load tMRSC(MAX) value to avoid timing
                                                         violations.
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t trc                          : 4;  /**< Row Cycle Time (represented in \#mclks)
                                                         see also: DFA_MEMRLD[RLCFG] field which must
                                                         correspond with tRL/tWL parameter(s).
                                                              - 0000-0010: RESERVED
                                                              - 0011: tRC = 3 mclks
                                                              - 0100: tRC = 4 mclks
                                                              - 0101: tRC = 5 mclks
                                                              - 0110: tRC = 6 mclks
                                                              - 0111: tRC = 7 mclks
                                                              - 1000: tRC = 8 mclks
                                                              - 1001: tRC = 9 mclks
                                                              - 1010-1111: RESERVED
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t twl                          : 4;  /**< Write Latency (represented in \#mclks)
                                                         see also: DFA_MEMRLD[RLCFG] field which must
                                                         correspond with tRL/tWL parameter(s).
                                                              - 0000-0001: RESERVED
                                                              - 0010: Write Latency (WL=2.0 mclk)
                                                              - 0011: Write Latency (WL=3.0 mclks)
                                                              - 0100: Write Latency (WL=4.0 mclks)
                                                              - 0101: Write Latency (WL=5.0 mclks)
                                                              - 0110: Write Latency (WL=6.0 mclks)
                                                              - 0111: Write Latency (WL=7.0 mclks)
                                                              - 1000: Write Latency (WL=8.0 mclks)
                                                              - 1001: Write Latency (WL=9.0 mclks)
                                                              - 1010: Write Latency (WL=10.0 mclks)
                                                              - 1011-1111: RESERVED
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t trl                          : 4;  /**< Read Latency (represented in \#mclks)
                                                         see also: DFA_MEMRLD[RLCFG] field which must
                                                         correspond with tRL/tWL parameter(s).
                                                              - 0000-0010: RESERVED
                                                              - 0011: Read Latency = 3 mclks
                                                              - 0100: Read Latency = 4 mclks
                                                              - 0101: Read Latency = 5 mclks
                                                              - 0110: Read Latency = 6 mclks
                                                              - 0111: Read Latency = 7 mclks
                                                              - 1000: Read Latency = 8 mclks
                                                              - 1001: Read Latency = 9 mclks
                                                              - 1010: Read Latency = 10 mclks
                                                              - 1011-1111: RESERVED
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t reserved_6_7                 : 2;
	uint64_t tskw                         : 2;  /**< Board Skew (represented in \#dclks)
                                                         Represents additional board skew of DQ/DQS.
                                                             - 00: board-skew = 0 dclk
                                                             - 01: board-skew = 1 dclk
                                                             - 10: board-skew = 2 dclk
                                                             - 11: board-skew = 3 dclk
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t ref_int                      : 4;  /**< Refresh Interval (represented in \#of 512 dclk
                                                         increments).
                                                              - 0000: RESERVED
                                                              - 0001: 1 * 512  = 512 dclks
                                                              - ...
                                                              - 1111: 15 * 512 = 7680 dclks
                                                         NOTE: For finer level of granularity, refer to
                                                         REF_INTLO[8:0] field.
                                                         For RLDRAM-II, each refresh interval will
                                                         generate a burst of 8 AREF commands, one to each of
                                                         8 explicit banks (referenced using the RLD_BA[2:0]
                                                         pins.
                                                         Example: For mclk=200MHz/dclk(400MHz=2.5ns):
                                                           64K AREF cycles required within tREF=32ms
                                                             trefint = tREF(ms)/(64K cycles/8banks)
                                                                     = 32ms/8K = 3.9us = 3900ns
                                                             REF_INT = ROUND_DOWN[(trefint/dclk)/512]
                                                                     = ROUND_DOWN[(3900/2.5)/512]
                                                                     = 3
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
#else
	uint64_t ref_int                      : 4;
	uint64_t tskw                         : 2;
	uint64_t reserved_6_7                 : 2;
	uint64_t trl                          : 4;
	uint64_t twl                          : 4;
	uint64_t trc                          : 4;
	uint64_t tmrsc                        : 3;
	uint64_t mrs_ena                      : 1;
	uint64_t aref_ena                     : 1;
	uint64_t ref_intlo                    : 9;
	uint64_t reserved_34_63               : 30;
#endif
	} s;
	struct cvmx_dfa_memcfg1_s             cn38xx;
	struct cvmx_dfa_memcfg1_s             cn38xxp2;
	struct cvmx_dfa_memcfg1_s             cn58xx;
	struct cvmx_dfa_memcfg1_s             cn58xxp1;
};
typedef union cvmx_dfa_memcfg1 cvmx_dfa_memcfg1_t;

/**
 * cvmx_dfa_memcfg2
 *
 * DFA_MEMCFG2 = DFA Memory Config Register \#2
 * *** NOTE: Pass2 Addition
 *
 * Description: Additional Memory Configuration CSRs to support FCRAM-II/II+ and Network DRAM-II
 */
union cvmx_dfa_memcfg2
{
	uint64_t u64;
	struct cvmx_dfa_memcfg2_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_12_63               : 52;
	uint64_t dteclkdis                    : 1;  /**< DFA DTE Clock Disable
                                                         When SET, the DFA clocks for DTE(thread engine)
                                                         operation are disabled.
                                                         NOTE: When SET, SW MUST NEVER issue ANY operations to
                                                         the DFA via the NCB Bus. All DFA Operations must be
                                                         issued solely through the CP2 interface.

                                                         NOTE: When DTECLKDIS=1, if CP2 Errors are encountered
                                                         (ie: CP2SBE, CP2DBE, CP2PERR), the DFA_MEMFADR CSR
                                                         does not reflect the failing address/ctl information. */
	uint64_t silrst                       : 1;  /**< LLM-PHY Silo Reset
                                                         When a '1' is written (when the previous
                                                         value was a '0') causes the the LLM-PHY Silo read/write
                                                         pointers to be reset.
                                                         NOTE: SW MUST WAIT 400 dclks after the LAST HW Init
                                                         sequence was launched (ie: INIT_START 0->1 CSR write),
                                                         before the SILRST can be triggered (0->1). */
	uint64_t trfc                         : 5;  /**< FCRAM-II Refresh Interval
                                                         *** CN58XX UNSUPPORTED *** */
	uint64_t refshort                     : 1;  /**< FCRAM Short Refresh Mode
                                                         *** CN58XX UNSUPPORTED *** */
	uint64_t ua_start                     : 2;  /**< FCRAM-II Upper Addres Start
                                                         *** CN58XX UNSUPPORTED *** */
	uint64_t maxbnk                       : 1;  /**< Maximum Banks per-device (used by the address mapper
                                                         when extracting address bits for the memory bank#.
                                                           - 0: 4 banks/device
                                                           - 1: 8 banks/device */
	uint64_t fcram2p                      : 1;  /**< FCRAM-II+ Mode Enable
                                                         *** CN58XX UNSUPPORTED *** */
#else
	uint64_t fcram2p                      : 1;
	uint64_t maxbnk                       : 1;
	uint64_t ua_start                     : 2;
	uint64_t refshort                     : 1;
	uint64_t trfc                         : 5;
	uint64_t silrst                       : 1;
	uint64_t dteclkdis                    : 1;
	uint64_t reserved_12_63               : 52;
#endif
	} s;
	struct cvmx_dfa_memcfg2_s             cn38xx;
	struct cvmx_dfa_memcfg2_s             cn38xxp2;
	struct cvmx_dfa_memcfg2_s             cn58xx;
	struct cvmx_dfa_memcfg2_s             cn58xxp1;
};
typedef union cvmx_dfa_memcfg2 cvmx_dfa_memcfg2_t;

/**
 * cvmx_dfa_memfadr
 *
 * DFA_MEMFADR = RLDRAM Failing Address/Control Register
 *
 * Description: DFA Memory Failing Address/Control Error Capture information
 * This register contains useful information to help in isolating an RLDRAM memory failure.
 * NOTE: The first detected SEC/DED/PERR failure is captured in DFA_MEMFADR, however, a DED or PERR (which is
 * more severe) will always overwrite a SEC error. The user can 'infer' the source of the interrupt
 * via the FSRC field.
 * NOTE: If DFA_MEMCFG2[DTECLKDIS]=1, the contents of this register are UNDEFINED.
 */
union cvmx_dfa_memfadr
{
	uint64_t u64;
	struct cvmx_dfa_memfadr_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_24_63               : 40;
	uint64_t maddr                        : 24; /**< Memory Address */
#else
	uint64_t maddr                        : 24;
	uint64_t reserved_24_63               : 40;
#endif
	} s;
	struct cvmx_dfa_memfadr_cn31xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_40_63               : 24;
	uint64_t fdst                         : 9;  /**< Fill-Destination
                                                            FSRC[1:0]    | FDST[8:0]
                                                            -------------+-------------------------------------
                                                             0(NCB-DTE)  | [fillstart,2'b0,WIDX(1),DMODE(1),DTE(4)]
                                                             1(NCB-CSR)  | [ncbSRC[8:0]]
                                                             3(CP2-PP)   | [2'b0,SIZE(1),INDEX(1),PP(4),FID(1)]
                                                           where:
                                                               DTE: DFA Thread Engine ID#
                                                               PP: Packet Processor ID#
                                                               FID: Fill-ID# (unique per PP)
                                                               WIDX:  16b SIMPLE Mode (index)
                                                               DMODE: (0=16b SIMPLE/1=32b SIMPLE)
                                                               SIZE: (0=LW Mode access/1=QW Mode Access)
                                                               INDEX: (0=Low LW/1=High LW)
                                                         NOTE: QW refers to a 56/64-bit LLM Load/Store (intiated
                                                         by a processor core). LW refers to a 32-bit load/store. */
	uint64_t fsrc                         : 2;  /**< Fill-Source (0=NCB-DTE/1=NCB-CSR/2=RESERVED/3=PP-CP2) */
	uint64_t pnum                         : 1;  /**< Memory Port
                                                         NOTE: For O2P, this bit will always return zero. */
	uint64_t bnum                         : 3;  /**< Memory Bank
                                                         When DFA_DDR2_ADDR[RNK_LO]=1, BNUM[2]=RANK[0].
                                                         (RANK[1] can be inferred from MADDR[24:0]) */
	uint64_t maddr                        : 25; /**< Memory Address */
#else
	uint64_t maddr                        : 25;
	uint64_t bnum                         : 3;
	uint64_t pnum                         : 1;
	uint64_t fsrc                         : 2;
	uint64_t fdst                         : 9;
	uint64_t reserved_40_63               : 24;
#endif
	} cn31xx;
	struct cvmx_dfa_memfadr_cn38xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_39_63               : 25;
	uint64_t fdst                         : 9;  /**< Fill-Destination
                                                            FSRC[1:0]    | FDST[8:0]
                                                            -------------+-------------------------------------
                                                             0(NCB-DTE)  | [fillstart,2'b0,WIDX(1),DMODE(1),DTE(4)]
                                                             1(NCB-CSR)  | [ncbSRC[8:0]]
                                                             3(CP2-PP)   | [2'b0,SIZE(1),INDEX(1),PP(4),FID(1)]
                                                           where:
                                                               DTE: DFA Thread Engine ID#
                                                               PP: Packet Processor ID#
                                                               FID: Fill-ID# (unique per PP)
                                                               WIDX:  18b SIMPLE Mode (index)
                                                               DMODE: (0=18b SIMPLE/1=36b SIMPLE)
                                                               SIZE: (0=LW Mode access/1=QW Mode Access)
                                                               INDEX: (0=Low LW/1=High LW)
                                                         NOTE: QW refers to a 64-bit LLM Load/Store (intiated
                                                         by a processor core). LW refers to a 36-bit load/store. */
	uint64_t fsrc                         : 2;  /**< Fill-Source (0=NCB-DTE/1=NCB-CSR/2=RESERVED/3=PP-CP2) */
	uint64_t pnum                         : 1;  /**< Memory Port
                                                         NOTE: the port id's are reversed
                                                            PNUM==0 => port#1
                                                            PNUM==1 => port#0 */
	uint64_t bnum                         : 3;  /**< Memory Bank */
	uint64_t maddr                        : 24; /**< Memory Address */
#else
	uint64_t maddr                        : 24;
	uint64_t bnum                         : 3;
	uint64_t pnum                         : 1;
	uint64_t fsrc                         : 2;
	uint64_t fdst                         : 9;
	uint64_t reserved_39_63               : 25;
#endif
	} cn38xx;
	struct cvmx_dfa_memfadr_cn38xx        cn38xxp2;
	struct cvmx_dfa_memfadr_cn38xx        cn58xx;
	struct cvmx_dfa_memfadr_cn38xx        cn58xxp1;
};
typedef union cvmx_dfa_memfadr cvmx_dfa_memfadr_t;

/**
 * cvmx_dfa_memfcr
 *
 * DFA_MEMFCR = FCRAM MRS Register(s) EMRS2[14:0], EMRS1[14:0], MRS[14:0]
 * *** CN58XX UNSUPPORTED ***
 *
 * Notes:
 * For FCRAM-II please consult your device's data sheet for further details:
 * MRS Definition:
 *    A[13:8]=0   RESERVED
 *    A[7]=0      TEST MODE     (N3K requires test mode 0:"disabled")
 *    A[6:4]      CAS LATENCY   (fully programmable - SW must ensure that the value programmed
 *                               into DFA_MEM_CFG0[TRL] corresponds with this value).
 *    A[3]=0      BURST TYPE    (N3K requires 0:"Sequential" Burst Type)
 *    A[2:0]      BURST LENGTH  Burst Length [1:BL2/2:BL4] (N3K only supports BL=2,4)
 *
 *                                  In BL2 mode(for highest performance), only 1/2 the phsyical
 *                                  memory is unique (ie: each bunk stores the same information).
 *                                  In BL4 mode(highest capacity), all of the physical memory
 *                                  is unique (ie: each bunk is uniquely addressable).
 * EMRS Definition:
 *    A[13:12]    REFRESH MODE  (N3K Supports only 0:"Conventional" and 1:"Short" auto-refresh modes)
 *
 *                              (SW must ensure that the value programmed into DFA_MEMCFG2[REFSHORT]
 *                              is also reflected in the Refresh Mode encoding).
 *    A[11:7]=0   RESERVED
 *    A[6:5]=2    STROBE SELECT (N3K supports only 2:"Unidirectional DS/QS" mode - the read capture
 *                              silos rely on a conditional QS strobe)
 *    A[4:3]      DIC(QS)       QS Drive Strength: fully programmable (consult your FCRAM-II data sheet)
 *                                [0: Normal Output Drive/1: Strong Output Drive/2: Weak output Drive]
 *    A[2:1]      DIC(DQ)       DQ Drive Strength: fully programmable (consult your FCRAM-II data sheet)
 *                                [0: Normal Output Drive/1: Strong Output Drive/2: Weak output Drive]
 *    A[0]        DLL           DLL Enable: Programmable [0:DLL Enable/1: DLL Disable]
 *
 * EMRS2 Definition: (for FCRAM-II+)
 *    A[13:11]=0                RESERVED
 *    A[10:8]     ODTDS         On Die Termination (DS+/-)
 *                                 [0: ODT Disable /1: 15ohm termination /(2-7): RESERVED]
 *    A[7:6]=0    MBW           Multi-Bank Write: (N3K requires use of 0:"single bank" mode only)
 *    A[5:3]      ODTin         On Die Termination (input pin)
 *                                 [0: ODT Disable /1: 15ohm termination /(2-7): RESERVED]
 *    A[2:0]      ODTDQ         On Die Termination (DQ)
 *                                 [0: ODT Disable /1: 15ohm termination /(2-7): RESERVED]
 */
union cvmx_dfa_memfcr
{
	uint64_t u64;
	struct cvmx_dfa_memfcr_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_47_63               : 17;
	uint64_t emrs2                        : 15; /**< Memory Address[14:0] during EMRS2(for FCRAM-II+)
                                                         *** CN58XX UNSUPPORTED *** */
	uint64_t reserved_31_31               : 1;
	uint64_t emrs                         : 15; /**< Memory Address[14:0] during EMRS
                                                         *** CN58XX UNSUPPORTED ***
                                                           A[0]=1: DLL Enabled) */
	uint64_t reserved_15_15               : 1;
	uint64_t mrs                          : 15; /**< FCRAM Memory Address[14:0] during MRS
                                                         *** CN58XX UNSUPPORTED ***
                                                           A[6:4]=4  CAS LATENCY=4(default)
                                                           A[3]=0    Burst Type(must be 0:Sequential)
                                                           A[2:0]=2  Burst Length=4(default) */
#else
	uint64_t mrs                          : 15;
	uint64_t reserved_15_15               : 1;
	uint64_t emrs                         : 15;
	uint64_t reserved_31_31               : 1;
	uint64_t emrs2                        : 15;
	uint64_t reserved_47_63               : 17;
#endif
	} s;
	struct cvmx_dfa_memfcr_s              cn38xx;
	struct cvmx_dfa_memfcr_s              cn38xxp2;
	struct cvmx_dfa_memfcr_s              cn58xx;
	struct cvmx_dfa_memfcr_s              cn58xxp1;
};
typedef union cvmx_dfa_memfcr cvmx_dfa_memfcr_t;

/**
 * cvmx_dfa_memhidat
 *
 * DFA_MEMHIDAT = DFA NCB-Direct CSR access to DFM Memory Space (High QW)
 *
 * Description:
 * DFA supports NCB-Direct CSR acccesses to DFM Memory space for debug purposes. Unfortunately, NCB-Direct accesses
 * are limited to QW-size(64bits), whereas the minimum access granularity for DFM Memory space is OW(128bits). To
 * support writes to DFM Memory space, the Hi-QW of data is sourced from the DFA_MEMHIDAT register. Recall, the
 * OW(128b) in DDR3 memory space is fixed format:
 *     OWDATA[127:118]: OWECC[9:0] 10bits of in-band OWECC SEC/DED codeword
 *                      This can be precomputed/written by SW OR
 *                      if DFM_FNTCTL[ECC_WENA]=1, DFM hardware will auto-compute the 10b OWECC and place in the
 *                      OWDATA[127:118] before being written to memory.
 *     OWDATA[117:0]:   Memory Data (contains fixed MNODE/MONODE arc formats for use by DTEs(thread engines).
 *                      Or, a user may choose to treat DFM Memory Space as 'scratch pad' in which case the
 *                      OWDATA[117:0] may contain user-specified information accessible via NCB-Direct CSR mode
 *                      accesses to DFA Memory Space.
 *  NOTE: To write to the DFA_MEMHIDAT register, a device would issue an IOBST directed at the DFA with addr[34:32]=3'b111.
 *        To read the DFA_MEMHIDAT register, a device would issue an IOBLD64 directed at the DFA with addr[34:32]=3'b111.
 *
 *  NOTE: If DFA_CONFIG[DTECLKDIS]=1 (DFA-DTE clocks disabled), reads/writes to the DFA_MEMHIDAT register do not take effect.
 *  NOTE: If FUSE[TBD]="DFA DTE disable" is blown, reads/writes to the DFA_MEMHIDAT register do not take effect.
 */
union cvmx_dfa_memhidat
{
	uint64_t u64;
	struct cvmx_dfa_memhidat_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t hidat                        : 64; /**< DFA Hi-QW of Write data during NCB-Direct DFM DDR3
                                                         Memory accesses.
                                                         All DFM DDR3 memory accesses are OW(128b) references,
                                                         and since NCB-Direct Mode writes only support QW(64b),
                                                         the Hi QW of data must be sourced from a CSR register.
                                                         NOTE: This single register is 'shared' for ALL DFM
                                                         DDR3 Memory writes. */
#else
	uint64_t hidat                        : 64;
#endif
	} s;
	struct cvmx_dfa_memhidat_s            cn63xx;
	struct cvmx_dfa_memhidat_s            cn63xxp1;
};
typedef union cvmx_dfa_memhidat cvmx_dfa_memhidat_t;

/**
 * cvmx_dfa_memrld
 *
 * DFA_MEMRLD = DFA RLDRAM MRS Register Values
 *
 * Description:
 */
union cvmx_dfa_memrld
{
	uint64_t u64;
	struct cvmx_dfa_memrld_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_23_63               : 41;
	uint64_t mrsdat                       : 23; /**< This field represents the data driven onto the
                                                         A[22:0] address lines during MRS(Mode Register Set)
                                                         commands (during a HW init sequence). This field
                                                         corresponds with the Mode Register Bit Map from
                                                         your RLDRAM-II device specific data sheet.
                                                            A[17:10]: RESERVED
                                                            A[9]:     ODT (on die termination)
                                                            A[8]:     Impedance Matching
                                                            A[7]:     DLL Reset
                                                            A[6]:     UNUSED
                                                            A[5]:     Address Mux  (for N3K: MUST BE ZERO)
                                                            A[4:3]:   Burst Length (for N3K: MUST BE ZERO)
                                                            A[2:0]:   Configuration (see data sheet for
                                                                      specific RLDRAM-II device).
                                                               - 000-001: CFG=1 [tRC=4/tRL=4/tWL=5]
                                                               - 010:     CFG=2 [tRC=6/tRL=6/tWL=7]
                                                               - 011:     CFG=3 [tRC=8/tRL=8/tWL=9]
                                                               - 100-111: RESERVED
                                                          NOTE: For additional density, the RLDRAM-II parts
                                                          can be 'clamshelled' (ie: two devices mounted on
                                                          different sides of the PCB board), since the BGA
                                                          pinout supports 'mirroring'.
                                                          To support a clamshell design, SW must preload
                                                          the MRSDAT[22:0] with the proper A[22:0] pin mapping
                                                          which is dependent on the 'selected' bunk/clam
                                                          (see also: DFA_MEMCFG0[BUNK_INIT] field).
                                                          NOTE: Care MUST BE TAKEN NOT to write to this register
                                                          within 64K eclk cycles of a HW INIT (see: INIT_P0/INIT_P1).
                                                          NOTE: This should only be written to a different value
                                                          during power-on SW initialization. */
#else
	uint64_t mrsdat                       : 23;
	uint64_t reserved_23_63               : 41;
#endif
	} s;
	struct cvmx_dfa_memrld_s              cn38xx;
	struct cvmx_dfa_memrld_s              cn38xxp2;
	struct cvmx_dfa_memrld_s              cn58xx;
	struct cvmx_dfa_memrld_s              cn58xxp1;
};
typedef union cvmx_dfa_memrld cvmx_dfa_memrld_t;

/**
 * cvmx_dfa_ncbctl
 *
 * DFA_NCBCTL = DFA NCB CTL Register
 *
 * Description:
 */
union cvmx_dfa_ncbctl
{
	uint64_t u64;
	struct cvmx_dfa_ncbctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_11_63               : 53;
	uint64_t sbdnum                       : 5;  /**< SBD Debug Entry#
                                                         For internal use only. (DFA Scoreboard debug)
                                                         Selects which one of 32 DFA Scoreboard entries is
                                                         latched into the DFA_SBD_DBG[0-3] registers. */
	uint64_t sbdlck                       : 1;  /**< DFA Scoreboard LOCK Strobe
                                                         For internal use only. (DFA Scoreboard debug)
                                                         When written with a '1', the DFA Scoreboard Debug
                                                         registers (DFA_SBD_DBG[0-3]) are all locked down.
                                                         This allows SW to lock down the contents of the entire
                                                         SBD for a single instant in time. All subsequent reads
                                                         of the DFA scoreboard registers will return the data
                                                         from that instant in time. */
	uint64_t dcmode                       : 1;  /**< DRF-CRQ/DTE Arbiter Mode
                                                         DTE-DRF Arbiter (0=FP [LP=CRQ/HP=DTE],1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t dtmode                       : 1;  /**< DRF-DTE Arbiter Mode
                                                         DTE-DRF Arbiter (0=FP [LP=DTE[15],...,HP=DTE[0]],1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t pmode                        : 1;  /**< NCB-NRP Arbiter Mode
                                                         (0=Fixed Priority [LP=WQF,DFF,HP=RGF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t qmode                        : 1;  /**< NCB-NRQ Arbiter Mode
                                                         (0=Fixed Priority [LP=IRF,RWF,PRF,HP=GRF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t imode                        : 1;  /**< NCB-Inbound Arbiter
                                                         (0=FP [LP=NRQ,HP=NRP], 1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
#else
	uint64_t imode                        : 1;
	uint64_t qmode                        : 1;
	uint64_t pmode                        : 1;
	uint64_t dtmode                       : 1;
	uint64_t dcmode                       : 1;
	uint64_t sbdlck                       : 1;
	uint64_t sbdnum                       : 5;
	uint64_t reserved_11_63               : 53;
#endif
	} s;
	struct cvmx_dfa_ncbctl_cn38xx
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_10_63               : 54;
	uint64_t sbdnum                       : 4;  /**< SBD Debug Entry#
                                                         For internal use only. (DFA Scoreboard debug)
                                                         Selects which one of 16 DFA Scoreboard entries is
                                                         latched into the DFA_SBD_DBG[0-3] registers. */
	uint64_t sbdlck                       : 1;  /**< DFA Scoreboard LOCK Strobe
                                                         For internal use only. (DFA Scoreboard debug)
                                                         When written with a '1', the DFA Scoreboard Debug
                                                         registers (DFA_SBD_DBG[0-3]) are all locked down.
                                                         This allows SW to lock down the contents of the entire
                                                         SBD for a single instant in time. All subsequent reads
                                                         of the DFA scoreboard registers will return the data
                                                         from that instant in time. */
	uint64_t dcmode                       : 1;  /**< DRF-CRQ/DTE Arbiter Mode
                                                         DTE-DRF Arbiter (0=FP [LP=CRQ/HP=DTE],1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t dtmode                       : 1;  /**< DRF-DTE Arbiter Mode
                                                         DTE-DRF Arbiter (0=FP [LP=DTE[15],...,HP=DTE[0]],1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t pmode                        : 1;  /**< NCB-NRP Arbiter Mode
                                                         (0=Fixed Priority [LP=WQF,DFF,HP=RGF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t qmode                        : 1;  /**< NCB-NRQ Arbiter Mode
                                                         (0=Fixed Priority [LP=IRF,RWF,PRF,HP=GRF]/1=RR
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
	uint64_t imode                        : 1;  /**< NCB-Inbound Arbiter
                                                         (0=FP [LP=NRQ,HP=NRP], 1=RR)
                                                         NOTE: This should only be written to a different value
                                                         during power-on SW initialization. */
#else
	uint64_t imode                        : 1;
	uint64_t qmode                        : 1;
	uint64_t pmode                        : 1;
	uint64_t dtmode                       : 1;
	uint64_t dcmode                       : 1;
	uint64_t sbdlck                       : 1;
	uint64_t sbdnum                       : 4;
	uint64_t reserved_10_63               : 54;
#endif
	} cn38xx;
	struct cvmx_dfa_ncbctl_cn38xx         cn38xxp2;
	struct cvmx_dfa_ncbctl_s              cn58xx;
	struct cvmx_dfa_ncbctl_s              cn58xxp1;
};
typedef union cvmx_dfa_ncbctl cvmx_dfa_ncbctl_t;

/**
 * cvmx_dfa_pfc0_cnt
 *
 * DFA_PFC0_CNT = DFA Performance Counter \#0
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc0_cnt
{
	uint64_t u64;
	struct cvmx_dfa_pfc0_cnt_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t pfcnt0                       : 64; /**< Performance Counter \#0
                                                         When DFA_PFC_GCTL[CNT0ENA]=1, the event selected
                                                         by DFA_PFC0_CTL[EVSEL] is counted.
                                                         See also DFA_PFC_GCTL[CNT0WCLR] and DFA_PFC_GCTL
                                                         [CNT0RCLR] for special clear count cases available
                                                         for SW data collection. */
#else
	uint64_t pfcnt0                       : 64;
#endif
	} s;
	struct cvmx_dfa_pfc0_cnt_s            cn63xx;
	struct cvmx_dfa_pfc0_cnt_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc0_cnt cvmx_dfa_pfc0_cnt_t;

/**
 * cvmx_dfa_pfc0_ctl
 *
 * DFA_PFC0_CTL = DFA Performance Counter#0 Control
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc0_ctl
{
	uint64_t u64;
	struct cvmx_dfa_pfc0_ctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_14_63               : 50;
	uint64_t evsel                        : 6;  /**< Performance Counter#0 Event Selector
                                                         // Events [0-31] are based on PMODE(0:per cluster-DTE 1:per graph)
                                                          - 0:  \#Total Cycles
                                                          - 1:  \#LDNODE visits
                                                          - 2:  \#SDNODE visits
                                                          - 3:  \#DNODE visits (LD/SD)
                                                          - 4:  \#LCNODE visits
                                                          - 5:  \#SCNODE visits
                                                          - 6:  \#CNODE visits (LC/SC)
                                                          - 7:  \#LMNODE visits
                                                          - 8:  \#SMNODE visits
                                                          - 9:  \#MNODE visits (LM/SM)
                                                           - 10: \#MONODE visits
                                                           - 11: \#CACHE visits (DNODE,CNODE) exc: CNDRD,MPHIDX
                                                           - 12: \#CACHE visits (DNODE,CNODE)+(CNDRD,MPHIDX)
                                                           - 13: \#MEMORY visits (MNODE+MONODE)
                                                           - 14: \#CNDRDs detected (occur for SCNODE->*MNODE transitions)
                                                           - 15: \#MPHIDX detected (occur for ->LMNODE transitions)
                                                           - 16: \#RESCANs detected (occur when HASH collision is detected)
                                                           - 17: \#GWALK iterations STALLED - Packet data/Result Buffer
                                                           - 18: \#GWALK iterations NON-STALLED
                                                           - 19: \#CLOAD iterations
                                                           - 20: \#MLOAD iterations
                                                               [NOTE: If PMODE=1(per-graph) the MLOAD IWORD0.VGID will be used to discern graph#].
                                                           - 21: \#RWORD1+ writes
                                                           - 22: \#cycles Cluster is busy
                                                           - 23: \#GWALK Instructions
                                                           - 24: \#CLOAD Instructions
                                                           - 25: \#MLOAD Instructions
                                                               [NOTE: If PMODE=1(per-graph) the MLOAD IWORD0.VGID will be used to discern graph#].
                                                           - 26: \#GFREE Instructions
                                                           - 27-30: RESERVED
                                                           - 31: \# Node Transitions detected (see DFA_PFC_GCTL[SNODE,ENODE,EDNODE] registers
                                                         //=============================================================
                                                         // Events [32-63] are used ONLY FOR PMODE=0(per-cluster DTE mode):
                                                           - 32: \#cycles a specific cluster-DTE remains active(valid state)
                                                           - 33: \#cycles a specific cluster-DTE waits for Memory Response Data
                                                           - 34: \#cycles a specific cluster-DTE waits in resource stall state
                                                                  (waiting for packet data or result buffer space)
                                                           - 35: \#cycles a specific cluster-DTE waits in resource pending state
                                                           - 36-63: RESERVED
                                                         //============================================================= */
	uint64_t reserved_6_7                 : 2;
	uint64_t cldte                        : 4;  /**< Performance Counter#0 Cluster DTE Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster's DTE# for all events
                                                         associated with Performance Counter#0. */
	uint64_t clnum                        : 2;  /**< Performance Counter#0 Cluster Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster# for all events
                                                         associated with Performance Counter#0. */
#else
	uint64_t clnum                        : 2;
	uint64_t cldte                        : 4;
	uint64_t reserved_6_7                 : 2;
	uint64_t evsel                        : 6;
	uint64_t reserved_14_63               : 50;
#endif
	} s;
	struct cvmx_dfa_pfc0_ctl_s            cn63xx;
	struct cvmx_dfa_pfc0_ctl_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc0_ctl cvmx_dfa_pfc0_ctl_t;

/**
 * cvmx_dfa_pfc1_cnt
 *
 * DFA_PFC1_CNT = DFA Performance Counter \#1
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc1_cnt
{
	uint64_t u64;
	struct cvmx_dfa_pfc1_cnt_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t pfcnt1                       : 64; /**< Performance Counter \#1
                                                         When DFA_PFC_GCTL[CNT1ENA]=1, the event selected
                                                         by DFA_PFC1_CTL[EVSEL] is counted.
                                                         See also DFA_PFC_GCTL[CNT1WCLR] and DFA_PFC_GCTL
                                                         [CNT1RCLR] for special clear count cases available
                                                         for SW data collection. */
#else
	uint64_t pfcnt1                       : 64;
#endif
	} s;
	struct cvmx_dfa_pfc1_cnt_s            cn63xx;
	struct cvmx_dfa_pfc1_cnt_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc1_cnt cvmx_dfa_pfc1_cnt_t;

/**
 * cvmx_dfa_pfc1_ctl
 *
 * DFA_PFC1_CTL = DFA Performance Counter#1 Control
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc1_ctl
{
	uint64_t u64;
	struct cvmx_dfa_pfc1_ctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_14_63               : 50;
	uint64_t evsel                        : 6;  /**< Performance Counter#1 Event Selector
                                                         - 0:  \#Cycles
                                                         - 1:  \#LDNODE visits
                                                         - 2:  \#SDNODE visits
                                                         - 3:  \#DNODE visits (LD/SD)
                                                         - 4:  \#LCNODE visits
                                                         - 5:  \#SCNODE visits
                                                         - 6:  \#CNODE visits (LC/SC)
                                                         - 7:  \#LMNODE visits
                                                         - 8:  \#SMNODE visits
                                                         - 9:  \#MNODE visits (LM/SM)
                                                          - 10: \#MONODE visits
                                                          - 11: \#CACHE visits (DNODE,CNODE) exc: CNDRD,MPHIDX
                                                          - 12: \#CACHE visits (DNODE,CNODE)+(CNDRD,MPHIDX)
                                                          - 13: \#MEMORY visits (MNODE+MONODE)
                                                          - 14: \#CNDRDs detected (occur for SCNODE->*MNODE transitions)
                                                          - 15: \#MPHIDX detected (occur for ->LMNODE transitions)
                                                          - 16: \#RESCANs detected (occur when HASH collision is detected)
                                                          - 17: \#GWALK STALLs detected - Packet data/Result Buffer
                                                          - 18: \#GWALK DTE cycles (all DTE-GNT[3a])
                                                          - 19: \#CLOAD DTE cycles
                                                          - 20: \#MLOAD DTE cycles
                                                          - 21: \#cycles waiting for Memory Response Data
                                                          - 22: \#cycles waiting in resource stall state (waiting for packet data or result buffer space)
                                                          - 23: \#cycles waiting in resource pending state
                                                          - 24: \#RWORD1+ writes
                                                          - 25: \#DTE-VLD cycles
                                                          - 26: \#DTE Transitions detected (see DFA_PFC_GCTL[SNODE,ENODE] registers
                                                          - 27: \#GWALK Instructions
                                                          - 28: \#CLOAD Instructions
                                                          - 29: \#MLOAD Instructions
                                                          - 30: \#GFREE Instructions (== \#GFREE DTE cycles)
                                                          - 31: RESERVED
                                                          - 32: \#DTE-Busy cycles (ALL DTE-GNT strobes) */
	uint64_t reserved_6_7                 : 2;
	uint64_t cldte                        : 4;  /**< Performance Counter#1 Cluster DTE Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster's DTE# for all events
                                                         associated with Performance Counter#1. */
	uint64_t clnum                        : 2;  /**< Performance Counter#1 Cluster Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster# for all events
                                                         associated with Performance Counter#1. */
#else
	uint64_t clnum                        : 2;
	uint64_t cldte                        : 4;
	uint64_t reserved_6_7                 : 2;
	uint64_t evsel                        : 6;
	uint64_t reserved_14_63               : 50;
#endif
	} s;
	struct cvmx_dfa_pfc1_ctl_s            cn63xx;
	struct cvmx_dfa_pfc1_ctl_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc1_ctl cvmx_dfa_pfc1_ctl_t;

/**
 * cvmx_dfa_pfc2_cnt
 *
 * DFA_PFC2_CNT = DFA Performance Counter \#2
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc2_cnt
{
	uint64_t u64;
	struct cvmx_dfa_pfc2_cnt_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t pfcnt2                       : 64; /**< Performance Counter \#2
                                                         When DFA_PFC_GCTL[CNT2ENA]=1, the event selected
                                                         by DFA_PFC2_CTL[EVSEL] is counted.
                                                         See also DFA_PFC_GCTL[CNT2WCLR] and DFA_PFC_GCTL
                                                         [CNT2RCLR] for special clear count cases available
                                                         for SW data collection. */
#else
	uint64_t pfcnt2                       : 64;
#endif
	} s;
	struct cvmx_dfa_pfc2_cnt_s            cn63xx;
	struct cvmx_dfa_pfc2_cnt_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc2_cnt cvmx_dfa_pfc2_cnt_t;

/**
 * cvmx_dfa_pfc2_ctl
 *
 * DFA_PFC2_CTL = DFA Performance Counter#2 Control
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc2_ctl
{
	uint64_t u64;
	struct cvmx_dfa_pfc2_ctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_14_63               : 50;
	uint64_t evsel                        : 6;  /**< Performance Counter#2 Event Selector
                                                         - 0:  \#Cycles
                                                         - 1:  \#LDNODE visits
                                                         - 2:  \#SDNODE visits
                                                         - 3:  \#DNODE visits (LD/SD)
                                                         - 4:  \#LCNODE visits
                                                         - 5:  \#SCNODE visits
                                                         - 6:  \#CNODE visits (LC/SC)
                                                         - 7:  \#LMNODE visits
                                                         - 8:  \#SMNODE visits
                                                         - 9:  \#MNODE visits (LM/SM)
                                                          - 10: \#MONODE visits
                                                          - 11: \#CACHE visits (DNODE,CNODE) exc: CNDRD,MPHIDX
                                                          - 12: \#CACHE visits (DNODE,CNODE)+(CNDRD,MPHIDX)
                                                          - 13: \#MEMORY visits (MNODE+MONODE)
                                                          - 14: \#CNDRDs detected (occur for SCNODE->*MNODE transitions)
                                                          - 15: \#MPHIDX detected (occur for ->LMNODE transitions)
                                                          - 16: \#RESCANs detected (occur when HASH collision is detected)
                                                          - 17: \#GWALK STALLs detected - Packet data/Result Buffer
                                                          - 18: \#GWALK DTE cycles (all DTE-GNT[3a])
                                                          - 19: \#CLOAD DTE cycles
                                                          - 20: \#MLOAD DTE cycles
                                                          - 21: \#cycles waiting for Memory Response Data
                                                          - 22: \#cycles waiting in resource stall state (waiting for packet data or result buffer space)
                                                          - 23: \#cycles waiting in resource pending state
                                                          - 24: \#RWORD1+ writes
                                                          - 25: \#DTE-VLD cycles
                                                          - 26: \#DTE Transitions detected (see DFA_PFC_GCTL[SNODE,ENODE] registers
                                                          - 27: \#GWALK Instructions
                                                          - 28: \#CLOAD Instructions
                                                          - 29: \#MLOAD Instructions
                                                          - 30: \#GFREE Instructions (== \#GFREE DTE cycles)
                                                          - 31: RESERVED
                                                          - 32: \#DTE-Busy cycles (ALL DTE-GNT strobes) */
	uint64_t reserved_6_7                 : 2;
	uint64_t cldte                        : 4;  /**< Performance Counter#2 Cluster DTE Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster's DTE# for all events
                                                         associated with Performance Counter#2. */
	uint64_t clnum                        : 2;  /**< Performance Counter#2 Cluster Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster# for all events
                                                         associated with Performance Counter#2. */
#else
	uint64_t clnum                        : 2;
	uint64_t cldte                        : 4;
	uint64_t reserved_6_7                 : 2;
	uint64_t evsel                        : 6;
	uint64_t reserved_14_63               : 50;
#endif
	} s;
	struct cvmx_dfa_pfc2_ctl_s            cn63xx;
	struct cvmx_dfa_pfc2_ctl_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc2_ctl cvmx_dfa_pfc2_ctl_t;

/**
 * cvmx_dfa_pfc3_cnt
 *
 * DFA_PFC3_CNT = DFA Performance Counter \#3
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc3_cnt
{
	uint64_t u64;
	struct cvmx_dfa_pfc3_cnt_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t pfcnt3                       : 64; /**< Performance Counter \#3
                                                         When DFA_PFC_GCTL[CNT3ENA]=1, the event selected
                                                         by DFA_PFC3_CTL[EVSEL] is counted.
                                                         See also DFA_PFC_GCTL[CNT3WCLR] and DFA_PFC_GCTL
                                                         [CNT3RCLR] for special clear count cases available
                                                         for SW data collection. */
#else
	uint64_t pfcnt3                       : 64;
#endif
	} s;
	struct cvmx_dfa_pfc3_cnt_s            cn63xx;
	struct cvmx_dfa_pfc3_cnt_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc3_cnt cvmx_dfa_pfc3_cnt_t;

/**
 * cvmx_dfa_pfc3_ctl
 *
 * DFA_PFC3_CTL = DFA Performance Counter#3 Control
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc3_ctl
{
	uint64_t u64;
	struct cvmx_dfa_pfc3_ctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_14_63               : 50;
	uint64_t evsel                        : 6;  /**< Performance Counter#3 Event Selector
                                                         - 0:  \#Cycles
                                                         - 1:  \#LDNODE visits
                                                         - 2:  \#SDNODE visits
                                                         - 3:  \#DNODE visits (LD/SD)
                                                         - 4:  \#LCNODE visits
                                                         - 5:  \#SCNODE visits
                                                         - 6:  \#CNODE visits (LC/SC)
                                                         - 7:  \#LMNODE visits
                                                         - 8:  \#SMNODE visits
                                                         - 9:  \#MNODE visits (LM/SM)
                                                          - 10: \#MONODE visits
                                                          - 11: \#CACHE visits (DNODE,CNODE) exc: CNDRD,MPHIDX
                                                          - 12: \#CACHE visits (DNODE,CNODE)+(CNDRD,MPHIDX)
                                                          - 13: \#MEMORY visits (MNODE+MONODE)
                                                          - 14: \#CNDRDs detected (occur for SCNODE->*MNODE transitions)
                                                          - 15: \#MPHIDX detected (occur for ->LMNODE transitions)
                                                          - 16: \#RESCANs detected (occur when HASH collision is detected)
                                                          - 17: \#GWALK STALLs detected - Packet data/Result Buffer
                                                          - 18: \#GWALK DTE cycles (all DTE-GNT[3a])
                                                          - 19: \#CLOAD DTE cycles
                                                          - 20: \#MLOAD DTE cycles
                                                          - 21: \#cycles waiting for Memory Response Data
                                                          - 22: \#cycles waiting in resource stall state (waiting for packet data or result buffer space)
                                                          - 23: \#cycles waiting in resource pending state
                                                          - 24: \#RWORD1+ writes
                                                          - 25: \#DTE-VLD cycles
                                                          - 26: \#DTE Transitions detected (see DFA_PFC_GCTL[SNODE,ENODE] registers
                                                          - 27: \#GWALK Instructions
                                                          - 28: \#CLOAD Instructions
                                                          - 29: \#MLOAD Instructions
                                                          - 30: \#GFREE Instructions (== \#GFREE DTE cycles)
                                                          - 31: RESERVED
                                                          - 32: \#DTE-Busy cycles (ALL DTE-GNT strobes) */
	uint64_t reserved_6_7                 : 2;
	uint64_t cldte                        : 4;  /**< Performance Counter#3 Cluster DTE Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster's DTE# for all events
                                                         associated with Performance Counter#3. */
	uint64_t clnum                        : 2;  /**< Performance Counter#3 Cluster Selector
                                                         When DFA_PFC_GCTL[PMODE]=0 (per-cluster DTE), this field
                                                         is used to select/monitor the cluster# for all events
                                                         associated with Performance Counter#3. */
#else
	uint64_t clnum                        : 2;
	uint64_t cldte                        : 4;
	uint64_t reserved_6_7                 : 2;
	uint64_t evsel                        : 6;
	uint64_t reserved_14_63               : 50;
#endif
	} s;
	struct cvmx_dfa_pfc3_ctl_s            cn63xx;
	struct cvmx_dfa_pfc3_ctl_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc3_ctl cvmx_dfa_pfc3_ctl_t;

/**
 * cvmx_dfa_pfc_gctl
 *
 * DFA_PFC_GCTL = DFA Performance Counter Global Control
 * *FOR INTERNAL USE ONLY*
 * Description:
 */
union cvmx_dfa_pfc_gctl
{
	uint64_t u64;
	struct cvmx_dfa_pfc_gctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_29_63               : 35;
	uint64_t vgid                         : 8;  /**< Virtual Graph Id#
                                                         When PMODE=1(per-graph selector), this field is used
                                                         to select/monitor only those events which are
                                                         associated with this selected VGID(virtual graph ID).
                                                         This field is used globally across all four performance
                                                         counters.
                                                         IMPNOTE: I implemented a global VGID across all 4 performance
                                                         counters to save wires/area. */
	uint64_t pmode                        : 1;  /**< Select Mode
                                                         - 0: Events are selected on a per-cluster DTE# (CLNUM/CLDTE)
                                                          DFA_PFCx_CTL[CLNUM,CLDTE] specifies the cluster-DTE for
                                                          each 1(of 4) performance counters.
                                                         - 1: Events are selected on a per-graph basis (VGID=virtual Graph ID).
                                                          NOTE: Only EVSEL=[0...31] can be used in conjunction with PMODE=1.
                                                          DFA_PFC_GCTL[VGID] specifies the Virtual graph ID used across
                                                          all four performance counters. */
	uint64_t ednode                       : 2;  /**< Ending DNODE Selector
                                                         When ENODE=0/1(*DNODE), this field is used to further
                                                         specify the Ending DNODE transition sub-type:
                                                           - 0: ALL DNODE sub-types
                                                           - 1: ->D2e (explicit DNODE transition node-arc alone transitions to DNODE)
                                                           - 2: ->D2i (implicit DNODE transition:arc-present triggers transition)
                                                           - 3: ->D1r (rescan DNODE transition) */
	uint64_t enode                        : 3;  /**< Ending Node Selector
                                                         When DFA_PFCx_CTL[EVSEL]=Node Transition(31), the ENODE
                                                         field is used to select Ending Node, and the SNODE
                                                         field is used to select the Starting Node.
                                                          - 0: LDNODE
                                                          - 1: SDNODE
                                                          - 2: LCNODE
                                                          - 3: SCNODE
                                                          - 4: LMNODE
                                                          - 5: SMNODE
                                                          - 6: MONODE
                                                          - 7: RESERVED */
	uint64_t snode                        : 3;  /**< Starting Node Selector
                                                         When DFA_PFCx_CTL[EVSEL]=Node Transition(31), the SNODE
                                                         field is used to select Starting Node, and the ENODE
                                                         field is used to select the Ending Node.
                                                          - 0: LDNODE
                                                          - 1: SDNODE
                                                          - 2: LCNODE
                                                          - 3: SCNODE
                                                          - 4: LMNODE
                                                          - 5: SMNODE
                                                          - 6: MONODE
                                                          - 7: RESERVED */
	uint64_t cnt3rclr                     : 1;  /**< Performance Counter \#3 Read Clear
                                                         If this bit is set, CSR reads to the DFA_PFC3_CNT
                                                         will clear the count value. This allows SW to maintain
                                                         'cumulative' counters to avoid HW wraparound. */
	uint64_t cnt2rclr                     : 1;  /**< Performance Counter \#2 Read Clear
                                                         If this bit is set, CSR reads to the DFA_PFC2_CNT
                                                         will clear the count value. This allows SW to maintain
                                                         'cumulative' counters to avoid HW wraparound. */
	uint64_t cnt1rclr                     : 1;  /**< Performance Counter \#1 Read Clear
                                                         If this bit is set, CSR reads to the DFA_PFC1_CNT
                                                         will clear the count value. This allows SW to maintain
                                                         'cumulative' counters to avoid HW wraparound. */
	uint64_t cnt0rclr                     : 1;  /**< Performance Counter \#0 Read Clear
                                                         If this bit is set, CSR reads to the DFA_PFC0_CNT
                                                         will clear the count value. This allows SW to maintain
                                                         'cumulative' counters to avoid HW wraparound. */
	uint64_t cnt3wclr                     : 1;  /**< Performance Counter \#3 Write Clear
                                                         If this bit is set, CSR writes to the DFA_PFC3_CNT
                                                         will clear the count value.
                                                         If this bit is clear, CSR writes to the DFA_PFC3_CNT
                                                         will continue the count from the written value. */
	uint64_t cnt2wclr                     : 1;  /**< Performance Counter \#2 Write Clear
                                                         If this bit is set, CSR writes to the DFA_PFC2_CNT
                                                         will clear the count value.
                                                         If this bit is clear, CSR writes to the DFA_PFC2_CNT
                                                         will continue the count from the written value. */
	uint64_t cnt1wclr                     : 1;  /**< Performance Counter \#1 Write Clear
                                                         If this bit is set, CSR writes to the DFA_PFC1_CNT
                                                         will clear the count value.
                                                         If this bit is clear, CSR writes to the DFA_PFC1_CNT
                                                         will continue the count from the written value. */
	uint64_t cnt0wclr                     : 1;  /**< Performance Counter \#0 Write Clear
                                                         If this bit is set, CSR writes to the DFA_PFC0_CNT
                                                         will clear the count value.
                                                         If this bit is clear, CSR writes to the DFA_PFC0_CNT
                                                         will continue the count from the written value. */
	uint64_t cnt3ena                      : 1;  /**< Performance Counter 3 Enable
                                                         When this bit is set, the performance counter \#3
                                                         is enabled. */
	uint64_t cnt2ena                      : 1;  /**< Performance Counter 2 Enable
                                                         When this bit is set, the performance counter \#2
                                                         is enabled. */
	uint64_t cnt1ena                      : 1;  /**< Performance Counter 1 Enable
                                                         When this bit is set, the performance counter \#1
                                                         is enabled. */
	uint64_t cnt0ena                      : 1;  /**< Performance Counter 0 Enable
                                                         When this bit is set, the performance counter \#0
                                                         is enabled. */
#else
	uint64_t cnt0ena                      : 1;
	uint64_t cnt1ena                      : 1;
	uint64_t cnt2ena                      : 1;
	uint64_t cnt3ena                      : 1;
	uint64_t cnt0wclr                     : 1;
	uint64_t cnt1wclr                     : 1;
	uint64_t cnt2wclr                     : 1;
	uint64_t cnt3wclr                     : 1;
	uint64_t cnt0rclr                     : 1;
	uint64_t cnt1rclr                     : 1;
	uint64_t cnt2rclr                     : 1;
	uint64_t cnt3rclr                     : 1;
	uint64_t snode                        : 3;
	uint64_t enode                        : 3;
	uint64_t ednode                       : 2;
	uint64_t pmode                        : 1;
	uint64_t vgid                         : 8;
	uint64_t reserved_29_63               : 35;
#endif
	} s;
	struct cvmx_dfa_pfc_gctl_s            cn63xx;
	struct cvmx_dfa_pfc_gctl_s            cn63xxp1;
};
typedef union cvmx_dfa_pfc_gctl cvmx_dfa_pfc_gctl_t;

/**
 * cvmx_dfa_rodt_comp_ctl
 *
 * DFA_RODT_COMP_CTL = DFA RLD Compensation control (For read "on die termination")
 *
 */
union cvmx_dfa_rodt_comp_ctl
{
	uint64_t u64;
	struct cvmx_dfa_rodt_comp_ctl_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t reserved_17_63               : 47;
	uint64_t enable                       : 1;  /**< Read On Die Termination Enable
                                                         (0=disable, 1=enable) */
	uint64_t reserved_12_15               : 4;
	uint64_t nctl                         : 4;  /**< Compensation control bits */
	uint64_t reserved_5_7                 : 3;
	uint64_t pctl                         : 5;  /**< Compensation control bits */
#else
	uint64_t pctl                         : 5;
	uint64_t reserved_5_7                 : 3;
	uint64_t nctl                         : 4;
	uint64_t reserved_12_15               : 4;
	uint64_t enable                       : 1;
	uint64_t reserved_17_63               : 47;
#endif
	} s;
	struct cvmx_dfa_rodt_comp_ctl_s       cn58xx;
	struct cvmx_dfa_rodt_comp_ctl_s       cn58xxp1;
};
typedef union cvmx_dfa_rodt_comp_ctl cvmx_dfa_rodt_comp_ctl_t;

/**
 * cvmx_dfa_sbd_dbg0
 *
 * DFA_SBD_DBG0 = DFA Scoreboard Debug \#0 Register
 *
 * Description: When the DFA_NCBCTL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_NCBCTL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_sbd_dbg0
{
	uint64_t u64;
	struct cvmx_dfa_sbd_dbg0_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd0                         : 64; /**< DFA ScoreBoard \#0 Data
                                                         For internal use only! (DFA Scoreboard Debug)
                                                         [63:40] rptr[26:3]: Result Base Pointer
                                                         [39:24] rwcnt[15:0] Cumulative Result Write Counter
                                                         [23]    lastgrdrsp: Last Gather-Rd Response
                                                         [22]    wtgrdrsp: Waiting Gather-Rd Response
                                                         [21]    wtgrdreq: Waiting for Gather-Rd Issue
                                                         [20]    glvld: GLPTR/GLCNT Valid
                                                         [19]    cmpmark: Completion Marked Node Detected
                                                         [18:17] cmpcode[1:0]: Completion Code
                                                                       [0=PDGONE/1=PERR/2=RFULL/3=TERM]
                                                         [16]    cmpdet: Completion Detected
                                                         [15]    wthdrwrcmtrsp: Waiting for HDR RWrCmtRsp
                                                         [14]    wtlastwrcmtrsp: Waiting for LAST RESULT
                                                                       RWrCmtRsp
                                                         [13]    hdrwrreq: Waiting for HDR RWrReq
                                                         [12]    wtrwrreq: Waiting for RWrReq
                                                         [11]    wtwqwrreq: Waiting for WQWrReq issue
                                                         [10]    lastprdrspeot: Last Packet-Rd Response
                                                         [9]     lastprdrsp: Last Packet-Rd Response
                                                         [8]     wtprdrsp:  Waiting for PRdRsp EOT
                                                         [7]     wtprdreq: Waiting for PRdReq Issue
                                                         [6]     lastpdvld: PDPTR/PDLEN Valid
                                                         [5]     pdvld: Packet Data Valid
                                                         [4]     wqvld: WQVLD
                                                         [3]     wqdone: WorkQueue Done condition
                                                                       a) WQWrReq issued(for WQPTR<>0) OR
                                                                       b) HDR RWrCmtRsp completed)
                                                         [2]     rwstf: Resultant write STF/P Mode
                                                         [1]     pdldt: Packet-Data LDT mode
                                                         [0]     gmode: Gather-Mode */
#else
	uint64_t sbd0                         : 64;
#endif
	} s;
	struct cvmx_dfa_sbd_dbg0_s            cn31xx;
	struct cvmx_dfa_sbd_dbg0_s            cn38xx;
	struct cvmx_dfa_sbd_dbg0_s            cn38xxp2;
	struct cvmx_dfa_sbd_dbg0_s            cn58xx;
	struct cvmx_dfa_sbd_dbg0_s            cn58xxp1;
};
typedef union cvmx_dfa_sbd_dbg0 cvmx_dfa_sbd_dbg0_t;

/**
 * cvmx_dfa_sbd_dbg1
 *
 * DFA_SBD_DBG1 = DFA Scoreboard Debug \#1 Register
 *
 * Description: When the DFA_NCBCTL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_NCBCTL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_sbd_dbg1
{
	uint64_t u64;
	struct cvmx_dfa_sbd_dbg1_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd1                         : 64; /**< DFA ScoreBoard \#1 Data
                                                         For internal use only! (DFA Scoreboard Debug)
                                                         [63:61] wqptr[35:33]: Work Queue Pointer
                                                         [60:52] rptr[35:27]: Result Base Pointer
                                                         [51:16] pdptr[35:0]: Packet Data Pointer
                                                         [15:0]  pdcnt[15:0]: Packet Data Counter */
#else
	uint64_t sbd1                         : 64;
#endif
	} s;
	struct cvmx_dfa_sbd_dbg1_s            cn31xx;
	struct cvmx_dfa_sbd_dbg1_s            cn38xx;
	struct cvmx_dfa_sbd_dbg1_s            cn38xxp2;
	struct cvmx_dfa_sbd_dbg1_s            cn58xx;
	struct cvmx_dfa_sbd_dbg1_s            cn58xxp1;
};
typedef union cvmx_dfa_sbd_dbg1 cvmx_dfa_sbd_dbg1_t;

/**
 * cvmx_dfa_sbd_dbg2
 *
 * DFA_SBD_DBG2 = DFA Scoreboard Debug \#2 Register
 *
 * Description: When the DFA_NCBCTL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_NCBCTL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_sbd_dbg2
{
	uint64_t u64;
	struct cvmx_dfa_sbd_dbg2_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd2                         : 64; /**< DFA ScoreBoard \#2 Data
                                                         [63:49] wqptr[17:3]: Work Queue Pointer
                                                         [48:16] rwptr[35:3]: Result Write Pointer
                                                         [15:0]  prwcnt[15:0]: Pending Result Write Counter */
#else
	uint64_t sbd2                         : 64;
#endif
	} s;
	struct cvmx_dfa_sbd_dbg2_s            cn31xx;
	struct cvmx_dfa_sbd_dbg2_s            cn38xx;
	struct cvmx_dfa_sbd_dbg2_s            cn38xxp2;
	struct cvmx_dfa_sbd_dbg2_s            cn58xx;
	struct cvmx_dfa_sbd_dbg2_s            cn58xxp1;
};
typedef union cvmx_dfa_sbd_dbg2 cvmx_dfa_sbd_dbg2_t;

/**
 * cvmx_dfa_sbd_dbg3
 *
 * DFA_SBD_DBG3 = DFA Scoreboard Debug \#3 Register
 *
 * Description: When the DFA_NCBCTL[SBDLCK] bit is written '1', the contents of this register are locked down.
 * Otherwise, the contents of this register are the 'active' contents of the DFA Scoreboard at the time of the
 * CSR read.
 * VERIFICATION NOTE: Read data is unsafe. X's(undefined data) can propagate (in the behavioral model)
 * on the reads unless the DTE Engine specified by DFA_NCBCTL[SBDNUM] has previously been assigned an
 * instruction.
 */
union cvmx_dfa_sbd_dbg3
{
	uint64_t u64;
	struct cvmx_dfa_sbd_dbg3_s
	{
#if __BYTE_ORDER == __BIG_ENDIAN
	uint64_t sbd3                         : 64; /**< DFA ScoreBoard \#3 Data
                                                         [63:49] wqptr[32:18]: Work Queue Pointer
                                                         [48:16] glptr[35:3]: Gather List Pointer
                                                         [15:0]  glcnt[15:0]: Gather List Counter */
#else
	uint64_t sbd3                         : 64;
#endif
	} s;
	struct cvmx_dfa_sbd_dbg3_s            cn31xx;
	struct cvmx_dfa_sbd_dbg3_s            cn38xx;
	struct cvmx_dfa_sbd_dbg3_s            cn38xxp2;
	struct cvmx_dfa_sbd_dbg3_s            cn58xx;
	struct cvmx_dfa_sbd_dbg3_s            cn58xxp1;
};
typedef union cvmx_dfa_sbd_dbg3 cvmx_dfa_sbd_dbg3_t;

#endif