/***********************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-mio-defs.h * * Configuration and status register (CSR) type definitions for * Octeon mio. * * This file is auto generated. Do not edit. * *

$Revision$

* */ #ifndef __CVMX_MIO_TYPEDEFS_H__ #define __CVMX_MIO_TYPEDEFS_H__ #define CVMX_MIO_BOOT_BIST_STAT (CVMX_ADD_IO_SEG(0x00011800000000F8ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_BOOT_COMP CVMX_MIO_BOOT_COMP_FUNC() static inline uint64_t CVMX_MIO_BOOT_COMP_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN50XX) || OCTEON_IS_MODEL(OCTEON_CN52XX) || OCTEON_IS_MODEL(OCTEON_CN56XX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_BOOT_COMP not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x00011800000000B8ull); } #else #define CVMX_MIO_BOOT_COMP (CVMX_ADD_IO_SEG(0x00011800000000B8ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_DMA_CFGX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 2))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_BOOT_DMA_CFGX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000100ull) + ((offset) & 3) * 8; } #else #define CVMX_MIO_BOOT_DMA_CFGX(offset) (CVMX_ADD_IO_SEG(0x0001180000000100ull) + ((offset) & 3) * 8) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_DMA_INTX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 2))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_BOOT_DMA_INTX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000138ull) + ((offset) & 3) * 8; } #else #define CVMX_MIO_BOOT_DMA_INTX(offset) (CVMX_ADD_IO_SEG(0x0001180000000138ull) + ((offset) & 3) * 8) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_DMA_INT_ENX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 2))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_BOOT_DMA_INT_ENX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000150ull) + ((offset) & 3) * 8; } #else #define CVMX_MIO_BOOT_DMA_INT_ENX(offset) (CVMX_ADD_IO_SEG(0x0001180000000150ull) + ((offset) & 3) * 8) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_DMA_TIMX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 2))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_BOOT_DMA_TIMX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000120ull) + ((offset) & 3) * 8; } #else #define CVMX_MIO_BOOT_DMA_TIMX(offset) (CVMX_ADD_IO_SEG(0x0001180000000120ull) + ((offset) & 3) * 8) #endif #define CVMX_MIO_BOOT_ERR (CVMX_ADD_IO_SEG(0x00011800000000A0ull)) #define CVMX_MIO_BOOT_INT (CVMX_ADD_IO_SEG(0x00011800000000A8ull)) #define CVMX_MIO_BOOT_LOC_ADR (CVMX_ADD_IO_SEG(0x0001180000000090ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_LOC_CFGX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_BOOT_LOC_CFGX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000080ull) + ((offset) & 1) * 8; } #else #define CVMX_MIO_BOOT_LOC_CFGX(offset) (CVMX_ADD_IO_SEG(0x0001180000000080ull) + ((offset) & 1) * 8) #endif #define CVMX_MIO_BOOT_LOC_DAT (CVMX_ADD_IO_SEG(0x0001180000000098ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_BOOT_PIN_DEFS CVMX_MIO_BOOT_PIN_DEFS_FUNC() static inline uint64_t CVMX_MIO_BOOT_PIN_DEFS_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX) || OCTEON_IS_MODEL(OCTEON_CN56XX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_BOOT_PIN_DEFS not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x00011800000000C0ull); } #else #define CVMX_MIO_BOOT_PIN_DEFS (CVMX_ADD_IO_SEG(0x00011800000000C0ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_REG_CFGX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 7))))) cvmx_warn("CVMX_MIO_BOOT_REG_CFGX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000000ull) + ((offset) & 7) * 8; } #else #define CVMX_MIO_BOOT_REG_CFGX(offset) (CVMX_ADD_IO_SEG(0x0001180000000000ull) + ((offset) & 7) * 8) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_BOOT_REG_TIMX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 7))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 7))))) cvmx_warn("CVMX_MIO_BOOT_REG_TIMX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000040ull) + ((offset) & 7) * 8; } #else #define CVMX_MIO_BOOT_REG_TIMX(offset) (CVMX_ADD_IO_SEG(0x0001180000000040ull) + ((offset) & 7) * 8) #endif #define CVMX_MIO_BOOT_THR (CVMX_ADD_IO_SEG(0x00011800000000B0ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_FUS_BNK_DATX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 3))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 3))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 3))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 3))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_FUS_BNK_DATX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000001520ull) + ((offset) & 3) * 8; } #else #define CVMX_MIO_FUS_BNK_DATX(offset) (CVMX_ADD_IO_SEG(0x0001180000001520ull) + ((offset) & 3) * 8) #endif #define CVMX_MIO_FUS_DAT0 (CVMX_ADD_IO_SEG(0x0001180000001400ull)) #define CVMX_MIO_FUS_DAT1 (CVMX_ADD_IO_SEG(0x0001180000001408ull)) #define CVMX_MIO_FUS_DAT2 (CVMX_ADD_IO_SEG(0x0001180000001410ull)) #define CVMX_MIO_FUS_DAT3 (CVMX_ADD_IO_SEG(0x0001180000001418ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_EMA CVMX_MIO_FUS_EMA_FUNC() static inline uint64_t CVMX_MIO_FUS_EMA_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN5XXX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_EMA not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001550ull); } #else #define CVMX_MIO_FUS_EMA (CVMX_ADD_IO_SEG(0x0001180000001550ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_PDF CVMX_MIO_FUS_PDF_FUNC() static inline uint64_t CVMX_MIO_FUS_PDF_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN5XXX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_PDF not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001420ull); } #else #define CVMX_MIO_FUS_PDF (CVMX_ADD_IO_SEG(0x0001180000001420ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_PLL CVMX_MIO_FUS_PLL_FUNC() static inline uint64_t CVMX_MIO_FUS_PLL_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN5XXX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_PLL not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001580ull); } #else #define CVMX_MIO_FUS_PLL (CVMX_ADD_IO_SEG(0x0001180000001580ull)) #endif #define CVMX_MIO_FUS_PROG (CVMX_ADD_IO_SEG(0x0001180000001510ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_PROG_TIMES CVMX_MIO_FUS_PROG_TIMES_FUNC() static inline uint64_t CVMX_MIO_FUS_PROG_TIMES_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN5XXX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_PROG_TIMES not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001518ull); } #else #define CVMX_MIO_FUS_PROG_TIMES (CVMX_ADD_IO_SEG(0x0001180000001518ull)) #endif #define CVMX_MIO_FUS_RCMD (CVMX_ADD_IO_SEG(0x0001180000001500ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_READ_TIMES CVMX_MIO_FUS_READ_TIMES_FUNC() static inline uint64_t CVMX_MIO_FUS_READ_TIMES_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_READ_TIMES not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001570ull); } #else #define CVMX_MIO_FUS_READ_TIMES (CVMX_ADD_IO_SEG(0x0001180000001570ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_REPAIR_RES0 CVMX_MIO_FUS_REPAIR_RES0_FUNC() static inline uint64_t CVMX_MIO_FUS_REPAIR_RES0_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_REPAIR_RES0 not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001558ull); } #else #define CVMX_MIO_FUS_REPAIR_RES0 (CVMX_ADD_IO_SEG(0x0001180000001558ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_REPAIR_RES1 CVMX_MIO_FUS_REPAIR_RES1_FUNC() static inline uint64_t CVMX_MIO_FUS_REPAIR_RES1_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_REPAIR_RES1 not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001560ull); } #else #define CVMX_MIO_FUS_REPAIR_RES1 (CVMX_ADD_IO_SEG(0x0001180000001560ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_REPAIR_RES2 CVMX_MIO_FUS_REPAIR_RES2_FUNC() static inline uint64_t CVMX_MIO_FUS_REPAIR_RES2_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_FUS_REPAIR_RES2 not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001568ull); } #else #define CVMX_MIO_FUS_REPAIR_RES2 (CVMX_ADD_IO_SEG(0x0001180000001568ull)) #endif #define CVMX_MIO_FUS_SPR_REPAIR_RES (CVMX_ADD_IO_SEG(0x0001180000001548ull)) #define CVMX_MIO_FUS_SPR_REPAIR_SUM (CVMX_ADD_IO_SEG(0x0001180000001540ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_FUS_UNLOCK CVMX_MIO_FUS_UNLOCK_FUNC() static inline uint64_t CVMX_MIO_FUS_UNLOCK_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN30XX) || OCTEON_IS_MODEL(OCTEON_CN31XX))) cvmx_warn("CVMX_MIO_FUS_UNLOCK not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001578ull); } #else #define CVMX_MIO_FUS_UNLOCK (CVMX_ADD_IO_SEG(0x0001180000001578ull)) #endif #define CVMX_MIO_FUS_WADR (CVMX_ADD_IO_SEG(0x0001180000001508ull)) #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_GPIO_COMP CVMX_MIO_GPIO_COMP_FUNC() static inline uint64_t CVMX_MIO_GPIO_COMP_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_GPIO_COMP not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x00011800000000C8ull); } #else #define CVMX_MIO_GPIO_COMP (CVMX_ADD_IO_SEG(0x00011800000000C8ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_NDF_DMA_CFG CVMX_MIO_NDF_DMA_CFG_FUNC() static inline uint64_t CVMX_MIO_NDF_DMA_CFG_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_NDF_DMA_CFG not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000168ull); } #else #define CVMX_MIO_NDF_DMA_CFG (CVMX_ADD_IO_SEG(0x0001180000000168ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_NDF_DMA_INT CVMX_MIO_NDF_DMA_INT_FUNC() static inline uint64_t CVMX_MIO_NDF_DMA_INT_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_NDF_DMA_INT not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000170ull); } #else #define CVMX_MIO_NDF_DMA_INT (CVMX_ADD_IO_SEG(0x0001180000000170ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_NDF_DMA_INT_EN CVMX_MIO_NDF_DMA_INT_EN_FUNC() static inline uint64_t CVMX_MIO_NDF_DMA_INT_EN_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX) || OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_NDF_DMA_INT_EN not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000178ull); } #else #define CVMX_MIO_NDF_DMA_INT_EN (CVMX_ADD_IO_SEG(0x0001180000000178ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PLL_CTL CVMX_MIO_PLL_CTL_FUNC() static inline uint64_t CVMX_MIO_PLL_CTL_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN30XX) || OCTEON_IS_MODEL(OCTEON_CN31XX))) cvmx_warn("CVMX_MIO_PLL_CTL not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001448ull); } #else #define CVMX_MIO_PLL_CTL (CVMX_ADD_IO_SEG(0x0001180000001448ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PLL_SETTING CVMX_MIO_PLL_SETTING_FUNC() static inline uint64_t CVMX_MIO_PLL_SETTING_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN30XX) || OCTEON_IS_MODEL(OCTEON_CN31XX))) cvmx_warn("CVMX_MIO_PLL_SETTING not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001440ull); } #else #define CVMX_MIO_PLL_SETTING (CVMX_ADD_IO_SEG(0x0001180000001440ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PTP_CLOCK_CFG CVMX_MIO_PTP_CLOCK_CFG_FUNC() static inline uint64_t CVMX_MIO_PTP_CLOCK_CFG_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_PTP_CLOCK_CFG not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001070000000F00ull); } #else #define CVMX_MIO_PTP_CLOCK_CFG (CVMX_ADD_IO_SEG(0x0001070000000F00ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PTP_CLOCK_COMP CVMX_MIO_PTP_CLOCK_COMP_FUNC() static inline uint64_t CVMX_MIO_PTP_CLOCK_COMP_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_PTP_CLOCK_COMP not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001070000000F18ull); } #else #define CVMX_MIO_PTP_CLOCK_COMP (CVMX_ADD_IO_SEG(0x0001070000000F18ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PTP_CLOCK_HI CVMX_MIO_PTP_CLOCK_HI_FUNC() static inline uint64_t CVMX_MIO_PTP_CLOCK_HI_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_PTP_CLOCK_HI not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001070000000F10ull); } #else #define CVMX_MIO_PTP_CLOCK_HI (CVMX_ADD_IO_SEG(0x0001070000000F10ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PTP_CLOCK_LO CVMX_MIO_PTP_CLOCK_LO_FUNC() static inline uint64_t CVMX_MIO_PTP_CLOCK_LO_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_PTP_CLOCK_LO not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001070000000F08ull); } #else #define CVMX_MIO_PTP_CLOCK_LO (CVMX_ADD_IO_SEG(0x0001070000000F08ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PTP_EVT_CNT CVMX_MIO_PTP_EVT_CNT_FUNC() static inline uint64_t CVMX_MIO_PTP_EVT_CNT_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_PTP_EVT_CNT not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001070000000F28ull); } #else #define CVMX_MIO_PTP_EVT_CNT (CVMX_ADD_IO_SEG(0x0001070000000F28ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_PTP_TIMESTAMP CVMX_MIO_PTP_TIMESTAMP_FUNC() static inline uint64_t CVMX_MIO_PTP_TIMESTAMP_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_PTP_TIMESTAMP not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001070000000F20ull); } #else #define CVMX_MIO_PTP_TIMESTAMP (CVMX_ADD_IO_SEG(0x0001070000000F20ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_RST_BOOT CVMX_MIO_RST_BOOT_FUNC() static inline uint64_t CVMX_MIO_RST_BOOT_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_RST_BOOT not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001600ull); } #else #define CVMX_MIO_RST_BOOT (CVMX_ADD_IO_SEG(0x0001180000001600ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_RST_CFG CVMX_MIO_RST_CFG_FUNC() static inline uint64_t CVMX_MIO_RST_CFG_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_RST_CFG not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001610ull); } #else #define CVMX_MIO_RST_CFG (CVMX_ADD_IO_SEG(0x0001180000001610ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_RST_CTLX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_RST_CTLX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000001618ull) + ((offset) & 1) * 8; } #else #define CVMX_MIO_RST_CTLX(offset) (CVMX_ADD_IO_SEG(0x0001180000001618ull) + ((offset) & 1) * 8) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_RST_DELAY CVMX_MIO_RST_DELAY_FUNC() static inline uint64_t CVMX_MIO_RST_DELAY_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_RST_DELAY not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001608ull); } #else #define CVMX_MIO_RST_DELAY (CVMX_ADD_IO_SEG(0x0001180000001608ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_RST_INT CVMX_MIO_RST_INT_FUNC() static inline uint64_t CVMX_MIO_RST_INT_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_RST_INT not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001628ull); } #else #define CVMX_MIO_RST_INT (CVMX_ADD_IO_SEG(0x0001180000001628ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_RST_INT_EN CVMX_MIO_RST_INT_EN_FUNC() static inline uint64_t CVMX_MIO_RST_INT_EN_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN63XX))) cvmx_warn("CVMX_MIO_RST_INT_EN not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000001630ull); } #else #define CVMX_MIO_RST_INT_EN (CVMX_ADD_IO_SEG(0x0001180000001630ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_TWSX_INT(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_TWSX_INT(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000001010ull) + ((offset) & 1) * 512; } #else #define CVMX_MIO_TWSX_INT(offset) (CVMX_ADD_IO_SEG(0x0001180000001010ull) + ((offset) & 1) * 512) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_TWSX_SW_TWSI(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_TWSX_SW_TWSI(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000001000ull) + ((offset) & 1) * 512; } #else #define CVMX_MIO_TWSX_SW_TWSI(offset) (CVMX_ADD_IO_SEG(0x0001180000001000ull) + ((offset) & 1) * 512) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_TWSX_SW_TWSI_EXT(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_TWSX_SW_TWSI_EXT(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000001018ull) + ((offset) & 1) * 512; } #else #define CVMX_MIO_TWSX_SW_TWSI_EXT(offset) (CVMX_ADD_IO_SEG(0x0001180000001018ull) + ((offset) & 1) * 512) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_TWSX_TWSI_SW(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset == 0))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_TWSX_TWSI_SW(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000001008ull) + ((offset) & 1) * 512; } #else #define CVMX_MIO_TWSX_TWSI_SW(offset) (CVMX_ADD_IO_SEG(0x0001180000001008ull) + ((offset) & 1) * 512) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_DLH CVMX_MIO_UART2_DLH_FUNC() static inline uint64_t CVMX_MIO_UART2_DLH_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_DLH not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000488ull); } #else #define CVMX_MIO_UART2_DLH (CVMX_ADD_IO_SEG(0x0001180000000488ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_DLL CVMX_MIO_UART2_DLL_FUNC() static inline uint64_t CVMX_MIO_UART2_DLL_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_DLL not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000480ull); } #else #define CVMX_MIO_UART2_DLL (CVMX_ADD_IO_SEG(0x0001180000000480ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_FAR CVMX_MIO_UART2_FAR_FUNC() static inline uint64_t CVMX_MIO_UART2_FAR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_FAR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000520ull); } #else #define CVMX_MIO_UART2_FAR (CVMX_ADD_IO_SEG(0x0001180000000520ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_FCR CVMX_MIO_UART2_FCR_FUNC() static inline uint64_t CVMX_MIO_UART2_FCR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_FCR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000450ull); } #else #define CVMX_MIO_UART2_FCR (CVMX_ADD_IO_SEG(0x0001180000000450ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_HTX CVMX_MIO_UART2_HTX_FUNC() static inline uint64_t CVMX_MIO_UART2_HTX_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_HTX not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000708ull); } #else #define CVMX_MIO_UART2_HTX (CVMX_ADD_IO_SEG(0x0001180000000708ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_IER CVMX_MIO_UART2_IER_FUNC() static inline uint64_t CVMX_MIO_UART2_IER_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_IER not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000408ull); } #else #define CVMX_MIO_UART2_IER (CVMX_ADD_IO_SEG(0x0001180000000408ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_IIR CVMX_MIO_UART2_IIR_FUNC() static inline uint64_t CVMX_MIO_UART2_IIR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_IIR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000410ull); } #else #define CVMX_MIO_UART2_IIR (CVMX_ADD_IO_SEG(0x0001180000000410ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_LCR CVMX_MIO_UART2_LCR_FUNC() static inline uint64_t CVMX_MIO_UART2_LCR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_LCR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000418ull); } #else #define CVMX_MIO_UART2_LCR (CVMX_ADD_IO_SEG(0x0001180000000418ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_LSR CVMX_MIO_UART2_LSR_FUNC() static inline uint64_t CVMX_MIO_UART2_LSR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_LSR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000428ull); } #else #define CVMX_MIO_UART2_LSR (CVMX_ADD_IO_SEG(0x0001180000000428ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_MCR CVMX_MIO_UART2_MCR_FUNC() static inline uint64_t CVMX_MIO_UART2_MCR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_MCR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000420ull); } #else #define CVMX_MIO_UART2_MCR (CVMX_ADD_IO_SEG(0x0001180000000420ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_MSR CVMX_MIO_UART2_MSR_FUNC() static inline uint64_t CVMX_MIO_UART2_MSR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_MSR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000430ull); } #else #define CVMX_MIO_UART2_MSR (CVMX_ADD_IO_SEG(0x0001180000000430ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_RBR CVMX_MIO_UART2_RBR_FUNC() static inline uint64_t CVMX_MIO_UART2_RBR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_RBR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000400ull); } #else #define CVMX_MIO_UART2_RBR (CVMX_ADD_IO_SEG(0x0001180000000400ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_RFL CVMX_MIO_UART2_RFL_FUNC() static inline uint64_t CVMX_MIO_UART2_RFL_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_RFL not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000608ull); } #else #define CVMX_MIO_UART2_RFL (CVMX_ADD_IO_SEG(0x0001180000000608ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_RFW CVMX_MIO_UART2_RFW_FUNC() static inline uint64_t CVMX_MIO_UART2_RFW_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_RFW not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000530ull); } #else #define CVMX_MIO_UART2_RFW (CVMX_ADD_IO_SEG(0x0001180000000530ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_SBCR CVMX_MIO_UART2_SBCR_FUNC() static inline uint64_t CVMX_MIO_UART2_SBCR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_SBCR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000620ull); } #else #define CVMX_MIO_UART2_SBCR (CVMX_ADD_IO_SEG(0x0001180000000620ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_SCR CVMX_MIO_UART2_SCR_FUNC() static inline uint64_t CVMX_MIO_UART2_SCR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_SCR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000438ull); } #else #define CVMX_MIO_UART2_SCR (CVMX_ADD_IO_SEG(0x0001180000000438ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_SFE CVMX_MIO_UART2_SFE_FUNC() static inline uint64_t CVMX_MIO_UART2_SFE_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_SFE not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000630ull); } #else #define CVMX_MIO_UART2_SFE (CVMX_ADD_IO_SEG(0x0001180000000630ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_SRR CVMX_MIO_UART2_SRR_FUNC() static inline uint64_t CVMX_MIO_UART2_SRR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_SRR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000610ull); } #else #define CVMX_MIO_UART2_SRR (CVMX_ADD_IO_SEG(0x0001180000000610ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_SRT CVMX_MIO_UART2_SRT_FUNC() static inline uint64_t CVMX_MIO_UART2_SRT_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_SRT not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000638ull); } #else #define CVMX_MIO_UART2_SRT (CVMX_ADD_IO_SEG(0x0001180000000638ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_SRTS CVMX_MIO_UART2_SRTS_FUNC() static inline uint64_t CVMX_MIO_UART2_SRTS_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_SRTS not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000618ull); } #else #define CVMX_MIO_UART2_SRTS (CVMX_ADD_IO_SEG(0x0001180000000618ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_STT CVMX_MIO_UART2_STT_FUNC() static inline uint64_t CVMX_MIO_UART2_STT_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_STT not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000700ull); } #else #define CVMX_MIO_UART2_STT (CVMX_ADD_IO_SEG(0x0001180000000700ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_TFL CVMX_MIO_UART2_TFL_FUNC() static inline uint64_t CVMX_MIO_UART2_TFL_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_TFL not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000600ull); } #else #define CVMX_MIO_UART2_TFL (CVMX_ADD_IO_SEG(0x0001180000000600ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_TFR CVMX_MIO_UART2_TFR_FUNC() static inline uint64_t CVMX_MIO_UART2_TFR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_TFR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000528ull); } #else #define CVMX_MIO_UART2_TFR (CVMX_ADD_IO_SEG(0x0001180000000528ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_THR CVMX_MIO_UART2_THR_FUNC() static inline uint64_t CVMX_MIO_UART2_THR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_THR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000440ull); } #else #define CVMX_MIO_UART2_THR (CVMX_ADD_IO_SEG(0x0001180000000440ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING #define CVMX_MIO_UART2_USR CVMX_MIO_UART2_USR_FUNC() static inline uint64_t CVMX_MIO_UART2_USR_FUNC(void) { if (!(OCTEON_IS_MODEL(OCTEON_CN52XX))) cvmx_warn("CVMX_MIO_UART2_USR not supported on this chip\n"); return CVMX_ADD_IO_SEG(0x0001180000000538ull); } #else #define CVMX_MIO_UART2_USR (CVMX_ADD_IO_SEG(0x0001180000000538ull)) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_DLH(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_DLH(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000888ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_DLH(offset) (CVMX_ADD_IO_SEG(0x0001180000000888ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_DLL(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_DLL(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000880ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_DLL(offset) (CVMX_ADD_IO_SEG(0x0001180000000880ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_FAR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_FAR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000920ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_FAR(offset) (CVMX_ADD_IO_SEG(0x0001180000000920ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_FCR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_FCR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000850ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_FCR(offset) (CVMX_ADD_IO_SEG(0x0001180000000850ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_HTX(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_HTX(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000B08ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_HTX(offset) (CVMX_ADD_IO_SEG(0x0001180000000B08ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_IER(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_IER(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000808ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_IER(offset) (CVMX_ADD_IO_SEG(0x0001180000000808ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_IIR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_IIR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000810ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_IIR(offset) (CVMX_ADD_IO_SEG(0x0001180000000810ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_LCR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_LCR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000818ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_LCR(offset) (CVMX_ADD_IO_SEG(0x0001180000000818ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_LSR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_LSR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000828ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_LSR(offset) (CVMX_ADD_IO_SEG(0x0001180000000828ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_MCR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_MCR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000820ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_MCR(offset) (CVMX_ADD_IO_SEG(0x0001180000000820ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_MSR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_MSR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000830ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_MSR(offset) (CVMX_ADD_IO_SEG(0x0001180000000830ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_RBR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_RBR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000800ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_RBR(offset) (CVMX_ADD_IO_SEG(0x0001180000000800ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_RFL(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_RFL(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A08ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_RFL(offset) (CVMX_ADD_IO_SEG(0x0001180000000A08ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_RFW(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_RFW(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000930ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_RFW(offset) (CVMX_ADD_IO_SEG(0x0001180000000930ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_SBCR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_SBCR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A20ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_SBCR(offset) (CVMX_ADD_IO_SEG(0x0001180000000A20ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_SCR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_SCR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000838ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_SCR(offset) (CVMX_ADD_IO_SEG(0x0001180000000838ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_SFE(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_SFE(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A30ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_SFE(offset) (CVMX_ADD_IO_SEG(0x0001180000000A30ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_SRR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_SRR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A10ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_SRR(offset) (CVMX_ADD_IO_SEG(0x0001180000000A10ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_SRT(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_SRT(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A38ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_SRT(offset) (CVMX_ADD_IO_SEG(0x0001180000000A38ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_SRTS(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_SRTS(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A18ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_SRTS(offset) (CVMX_ADD_IO_SEG(0x0001180000000A18ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_STT(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_STT(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000B00ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_STT(offset) (CVMX_ADD_IO_SEG(0x0001180000000B00ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_TFL(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_TFL(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000A00ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_TFL(offset) (CVMX_ADD_IO_SEG(0x0001180000000A00ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_TFR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_TFR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000928ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_TFR(offset) (CVMX_ADD_IO_SEG(0x0001180000000928ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_THR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_THR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000840ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_THR(offset) (CVMX_ADD_IO_SEG(0x0001180000000840ull) + ((offset) & 1) * 1024) #endif #if CVMX_ENABLE_CSR_ADDRESS_CHECKING static inline uint64_t CVMX_MIO_UARTX_USR(unsigned long offset) { if (!( (OCTEON_IS_MODEL(OCTEON_CN30XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN31XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN38XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN50XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN52XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN56XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN58XX) && ((offset <= 1))) || (OCTEON_IS_MODEL(OCTEON_CN63XX) && ((offset <= 1))))) cvmx_warn("CVMX_MIO_UARTX_USR(%lu) is invalid on this chip\n", offset); return CVMX_ADD_IO_SEG(0x0001180000000938ull) + ((offset) & 1) * 1024; } #else #define CVMX_MIO_UARTX_USR(offset) (CVMX_ADD_IO_SEG(0x0001180000000938ull) + ((offset) & 1) * 1024) #endif /** * cvmx_mio_boot_bist_stat * * MIO_BOOT_BIST_STAT = MIO Boot BIST Status Register * * Contains the BIST status for the MIO boot memories. '0' = pass, '1' = fail. */ union cvmx_mio_boot_bist_stat { uint64_t u64; struct cvmx_mio_boot_bist_stat_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_0_63 : 64; #else uint64_t reserved_0_63 : 64; #endif } s; struct cvmx_mio_boot_bist_stat_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_4_63 : 60; uint64_t ncbo_1 : 1; /**< NCB output FIFO 1 BIST status */ uint64_t ncbo_0 : 1; /**< NCB output FIFO 0 BIST status */ uint64_t loc : 1; /**< Local memory BIST status */ uint64_t ncbi : 1; /**< NCB input FIFO BIST status */ #else uint64_t ncbi : 1; uint64_t loc : 1; uint64_t ncbo_0 : 1; uint64_t ncbo_1 : 1; uint64_t reserved_4_63 : 60; #endif } cn30xx; struct cvmx_mio_boot_bist_stat_cn30xx cn31xx; struct cvmx_mio_boot_bist_stat_cn38xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_3_63 : 61; uint64_t ncbo_0 : 1; /**< NCB output FIFO BIST status */ uint64_t loc : 1; /**< Local memory BIST status */ uint64_t ncbi : 1; /**< NCB input FIFO BIST status */ #else uint64_t ncbi : 1; uint64_t loc : 1; uint64_t ncbo_0 : 1; uint64_t reserved_3_63 : 61; #endif } cn38xx; struct cvmx_mio_boot_bist_stat_cn38xx cn38xxp2; struct cvmx_mio_boot_bist_stat_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_6_63 : 58; uint64_t pcm_1 : 1; /**< PCM memory 1 BIST status */ uint64_t pcm_0 : 1; /**< PCM memory 0 BIST status */ uint64_t ncbo_1 : 1; /**< NCB output FIFO 1 BIST status */ uint64_t ncbo_0 : 1; /**< NCB output FIFO 0 BIST status */ uint64_t loc : 1; /**< Local memory BIST status */ uint64_t ncbi : 1; /**< NCB input FIFO BIST status */ #else uint64_t ncbi : 1; uint64_t loc : 1; uint64_t ncbo_0 : 1; uint64_t ncbo_1 : 1; uint64_t pcm_0 : 1; uint64_t pcm_1 : 1; uint64_t reserved_6_63 : 58; #endif } cn50xx; struct cvmx_mio_boot_bist_stat_cn52xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_6_63 : 58; uint64_t ndf : 2; /**< NAND flash BIST status */ uint64_t ncbo_0 : 1; /**< NCB output FIFO BIST status */ uint64_t dma : 1; /**< DMA memory BIST status */ uint64_t loc : 1; /**< Local memory BIST status */ uint64_t ncbi : 1; /**< NCB input FIFO BIST status */ #else uint64_t ncbi : 1; uint64_t loc : 1; uint64_t dma : 1; uint64_t ncbo_0 : 1; uint64_t ndf : 2; uint64_t reserved_6_63 : 58; #endif } cn52xx; struct cvmx_mio_boot_bist_stat_cn52xxp1 { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_4_63 : 60; uint64_t ncbo_0 : 1; /**< NCB output FIFO BIST status */ uint64_t dma : 1; /**< DMA memory BIST status */ uint64_t loc : 1; /**< Local memory BIST status */ uint64_t ncbi : 1; /**< NCB input FIFO BIST status */ #else uint64_t ncbi : 1; uint64_t loc : 1; uint64_t dma : 1; uint64_t ncbo_0 : 1; uint64_t reserved_4_63 : 60; #endif } cn52xxp1; struct cvmx_mio_boot_bist_stat_cn52xxp1 cn56xx; struct cvmx_mio_boot_bist_stat_cn52xxp1 cn56xxp1; struct cvmx_mio_boot_bist_stat_cn38xx cn58xx; struct cvmx_mio_boot_bist_stat_cn38xx cn58xxp1; struct cvmx_mio_boot_bist_stat_cn63xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_9_63 : 55; uint64_t stat : 9; /**< BIST status */ #else uint64_t stat : 9; uint64_t reserved_9_63 : 55; #endif } cn63xx; struct cvmx_mio_boot_bist_stat_cn63xx cn63xxp1; }; typedef union cvmx_mio_boot_bist_stat cvmx_mio_boot_bist_stat_t; /** * cvmx_mio_boot_comp * * MIO_BOOT_COMP = MIO Boot Compensation Register * * Reset value is as follows: * * no pullups, PCTL=38, NCTL=30 (25 ohm termination) * pullup on boot_ad[9], PCTL=19, NCTL=15 (50 ohm termination) * pullup on boot_ad[10], PCTL=15, NCTL=12 (65 ohm termination) * pullups on boot_ad[10:9], PCTL=15, NCTL=12 (65 ohm termination) */ union cvmx_mio_boot_comp { uint64_t u64; struct cvmx_mio_boot_comp_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_0_63 : 64; #else uint64_t reserved_0_63 : 64; #endif } s; struct cvmx_mio_boot_comp_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t pctl : 5; /**< Boot bus PCTL */ uint64_t nctl : 5; /**< Boot bus NCTL */ #else uint64_t nctl : 5; uint64_t pctl : 5; uint64_t reserved_10_63 : 54; #endif } cn50xx; struct cvmx_mio_boot_comp_cn50xx cn52xx; struct cvmx_mio_boot_comp_cn50xx cn52xxp1; struct cvmx_mio_boot_comp_cn50xx cn56xx; struct cvmx_mio_boot_comp_cn50xx cn56xxp1; struct cvmx_mio_boot_comp_cn63xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_12_63 : 52; uint64_t pctl : 6; /**< Boot bus PCTL */ uint64_t nctl : 6; /**< Boot bus NCTL */ #else uint64_t nctl : 6; uint64_t pctl : 6; uint64_t reserved_12_63 : 52; #endif } cn63xx; struct cvmx_mio_boot_comp_cn63xx cn63xxp1; }; typedef union cvmx_mio_boot_comp cvmx_mio_boot_comp_t; /** * cvmx_mio_boot_dma_cfg# * * MIO_BOOT_DMA_CFG = MIO Boot DMA Config Register (1 per engine * 2 engines) * * SIZE is specified in number of bus transfers, where one transfer is equal to the following number * of bytes dependent on MIO_BOOT_DMA_TIMn[WIDTH] and MIO_BOOT_DMA_TIMn[DDR]: * * WIDTH DDR Transfer Size (bytes) * ---------------------------------------- * 0 0 2 * 0 1 4 * 1 0 4 * 1 1 8 * * Note: ADR must be aligned to the bus width (i.e. 16 bit aligned if WIDTH=0, 32 bit aligned if WIDTH=1). */ union cvmx_mio_boot_dma_cfgx { uint64_t u64; struct cvmx_mio_boot_dma_cfgx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t en : 1; /**< DMA Engine X enable */ uint64_t rw : 1; /**< DMA Engine X R/W bit (0 = read, 1 = write) */ uint64_t clr : 1; /**< DMA Engine X clear EN on device terminated burst */ uint64_t reserved_60_60 : 1; uint64_t swap32 : 1; /**< DMA Engine X 32 bit swap */ uint64_t swap16 : 1; /**< DMA Engine X 16 bit swap */ uint64_t swap8 : 1; /**< DMA Engine X 8 bit swap */ uint64_t endian : 1; /**< DMA Engine X NCB endian mode (0 = big, 1 = little) */ uint64_t size : 20; /**< DMA Engine X size */ uint64_t adr : 36; /**< DMA Engine X address */ #else uint64_t adr : 36; uint64_t size : 20; uint64_t endian : 1; uint64_t swap8 : 1; uint64_t swap16 : 1; uint64_t swap32 : 1; uint64_t reserved_60_60 : 1; uint64_t clr : 1; uint64_t rw : 1; uint64_t en : 1; #endif } s; struct cvmx_mio_boot_dma_cfgx_s cn52xx; struct cvmx_mio_boot_dma_cfgx_s cn52xxp1; struct cvmx_mio_boot_dma_cfgx_s cn56xx; struct cvmx_mio_boot_dma_cfgx_s cn56xxp1; struct cvmx_mio_boot_dma_cfgx_s cn63xx; struct cvmx_mio_boot_dma_cfgx_s cn63xxp1; }; typedef union cvmx_mio_boot_dma_cfgx cvmx_mio_boot_dma_cfgx_t; /** * cvmx_mio_boot_dma_int# * * MIO_BOOT_DMA_INT = MIO Boot DMA Interrupt Register (1 per engine * 2 engines) * */ union cvmx_mio_boot_dma_intx { uint64_t u64; struct cvmx_mio_boot_dma_intx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t dmarq : 1; /**< DMA Engine X DMARQ asserted interrupt */ uint64_t done : 1; /**< DMA Engine X request completion interrupt */ #else uint64_t done : 1; uint64_t dmarq : 1; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_boot_dma_intx_s cn52xx; struct cvmx_mio_boot_dma_intx_s cn52xxp1; struct cvmx_mio_boot_dma_intx_s cn56xx; struct cvmx_mio_boot_dma_intx_s cn56xxp1; struct cvmx_mio_boot_dma_intx_s cn63xx; struct cvmx_mio_boot_dma_intx_s cn63xxp1; }; typedef union cvmx_mio_boot_dma_intx cvmx_mio_boot_dma_intx_t; /** * cvmx_mio_boot_dma_int_en# * * MIO_BOOT_DMA_INT_EN = MIO Boot DMA Interrupt Enable Register (1 per engine * 2 engines) * */ union cvmx_mio_boot_dma_int_enx { uint64_t u64; struct cvmx_mio_boot_dma_int_enx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t dmarq : 1; /**< DMA Engine X DMARQ asserted interrupt enable */ uint64_t done : 1; /**< DMA Engine X request completion interrupt enable */ #else uint64_t done : 1; uint64_t dmarq : 1; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_boot_dma_int_enx_s cn52xx; struct cvmx_mio_boot_dma_int_enx_s cn52xxp1; struct cvmx_mio_boot_dma_int_enx_s cn56xx; struct cvmx_mio_boot_dma_int_enx_s cn56xxp1; struct cvmx_mio_boot_dma_int_enx_s cn63xx; struct cvmx_mio_boot_dma_int_enx_s cn63xxp1; }; typedef union cvmx_mio_boot_dma_int_enx cvmx_mio_boot_dma_int_enx_t; /** * cvmx_mio_boot_dma_tim# * * MIO_BOOT_DMA_TIM = MIO Boot DMA Timing Register (1 per engine * 2 engines) * * DMACK_PI inverts the assertion level of boot_dmack[n]. The default polarity of boot_dmack[1:0] is * selected on the first de-assertion of reset by the values on boot_ad[12:11], where 0 is active high * and 1 is active low (see MIO_BOOT_PIN_DEFS for a read-only copy of the default polarity). * boot_ad[12:11] have internal pulldowns, so place a pullup on boot_ad[n+11] for active low default * polarity on engine n. To interface with CF cards in True IDE Mode, either a pullup should be placed * on boot_ad[n+11] OR the corresponding DMACK_PI[n] should be set. * * DMARQ_PI inverts the assertion level of boot_dmarq[n]. The default polarity of boot_dmarq[1:0] is * active high, thus setting the polarity inversion bits changes the polarity to active low. To * interface with CF cards in True IDE Mode, the corresponding DMARQ_PI[n] should be clear. * * TIM_MULT specifies the timing multiplier for an engine. The timing multiplier applies to all timing * parameters, except for DMARQ and RD_DLY, which simply count eclks. TIM_MULT is encoded as follows: * 0 = 4x, 1 = 1x, 2 = 2x, 3 = 8x. * * RD_DLY specifies the read sample delay in eclk cycles for an engine. For reads, the data bus is * normally sampled on the same eclk edge that drives boot_oe_n high (and also low in DDR mode). * This parameter can delay that sampling edge by up to 7 eclks. Note: the number of eclk cycles * counted by the OE_A and DMACK_H + PAUSE timing parameters must be greater than RD_DLY. * * If DDR is set, then WE_N must be less than WE_A. */ union cvmx_mio_boot_dma_timx { uint64_t u64; struct cvmx_mio_boot_dma_timx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t dmack_pi : 1; /**< DMA Engine X DMA ack polarity inversion */ uint64_t dmarq_pi : 1; /**< DMA Engine X DMA request polarity inversion */ uint64_t tim_mult : 2; /**< DMA Engine X timing multiplier */ uint64_t rd_dly : 3; /**< DMA Engine X read sample delay */ uint64_t ddr : 1; /**< DMA Engine X DDR mode */ uint64_t width : 1; /**< DMA Engine X bus width (0 = 16 bits, 1 = 32 bits) */ uint64_t reserved_48_54 : 7; uint64_t pause : 6; /**< DMA Engine X pause count */ uint64_t dmack_h : 6; /**< DMA Engine X DMA ack hold count */ uint64_t we_n : 6; /**< DMA Engine X write enable negated count */ uint64_t we_a : 6; /**< DMA Engine X write enable asserted count */ uint64_t oe_n : 6; /**< DMA Engine X output enable negated count */ uint64_t oe_a : 6; /**< DMA Engine X output enable asserted count */ uint64_t dmack_s : 6; /**< DMA Engine X DMA ack setup count */ uint64_t dmarq : 6; /**< DMA Engine X DMA request count (must be non-zero) */ #else uint64_t dmarq : 6; uint64_t dmack_s : 6; uint64_t oe_a : 6; uint64_t oe_n : 6; uint64_t we_a : 6; uint64_t we_n : 6; uint64_t dmack_h : 6; uint64_t pause : 6; uint64_t reserved_48_54 : 7; uint64_t width : 1; uint64_t ddr : 1; uint64_t rd_dly : 3; uint64_t tim_mult : 2; uint64_t dmarq_pi : 1; uint64_t dmack_pi : 1; #endif } s; struct cvmx_mio_boot_dma_timx_s cn52xx; struct cvmx_mio_boot_dma_timx_s cn52xxp1; struct cvmx_mio_boot_dma_timx_s cn56xx; struct cvmx_mio_boot_dma_timx_s cn56xxp1; struct cvmx_mio_boot_dma_timx_s cn63xx; struct cvmx_mio_boot_dma_timx_s cn63xxp1; }; typedef union cvmx_mio_boot_dma_timx cvmx_mio_boot_dma_timx_t; /** * cvmx_mio_boot_err * * MIO_BOOT_ERR = MIO Boot Error Register * * Contains the address decode error and wait mode error bits. Address decode error is set when a * boot bus access does not hit in any of the 8 remote regions or 2 local regions. Wait mode error is * set when wait mode is enabled and the external wait signal is not de-asserted after 32k eclk cycles. */ union cvmx_mio_boot_err { uint64_t u64; struct cvmx_mio_boot_err_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t wait_err : 1; /**< Wait mode error */ uint64_t adr_err : 1; /**< Address decode error */ #else uint64_t adr_err : 1; uint64_t wait_err : 1; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_boot_err_s cn30xx; struct cvmx_mio_boot_err_s cn31xx; struct cvmx_mio_boot_err_s cn38xx; struct cvmx_mio_boot_err_s cn38xxp2; struct cvmx_mio_boot_err_s cn50xx; struct cvmx_mio_boot_err_s cn52xx; struct cvmx_mio_boot_err_s cn52xxp1; struct cvmx_mio_boot_err_s cn56xx; struct cvmx_mio_boot_err_s cn56xxp1; struct cvmx_mio_boot_err_s cn58xx; struct cvmx_mio_boot_err_s cn58xxp1; struct cvmx_mio_boot_err_s cn63xx; struct cvmx_mio_boot_err_s cn63xxp1; }; typedef union cvmx_mio_boot_err cvmx_mio_boot_err_t; /** * cvmx_mio_boot_int * * MIO_BOOT_INT = MIO Boot Interrupt Register * * Contains the interrupt enable bits for address decode error and wait mode error. */ union cvmx_mio_boot_int { uint64_t u64; struct cvmx_mio_boot_int_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t wait_int : 1; /**< Wait mode error interrupt enable */ uint64_t adr_int : 1; /**< Address decode error interrupt enable */ #else uint64_t adr_int : 1; uint64_t wait_int : 1; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_boot_int_s cn30xx; struct cvmx_mio_boot_int_s cn31xx; struct cvmx_mio_boot_int_s cn38xx; struct cvmx_mio_boot_int_s cn38xxp2; struct cvmx_mio_boot_int_s cn50xx; struct cvmx_mio_boot_int_s cn52xx; struct cvmx_mio_boot_int_s cn52xxp1; struct cvmx_mio_boot_int_s cn56xx; struct cvmx_mio_boot_int_s cn56xxp1; struct cvmx_mio_boot_int_s cn58xx; struct cvmx_mio_boot_int_s cn58xxp1; struct cvmx_mio_boot_int_s cn63xx; struct cvmx_mio_boot_int_s cn63xxp1; }; typedef union cvmx_mio_boot_int cvmx_mio_boot_int_t; /** * cvmx_mio_boot_loc_adr * * MIO_BOOT_LOC_ADR = MIO Boot Local Memory Address Register * * Specifies the address for reading or writing the local memory. This address will post-increment * following an access to the MIO Boot Local Memory Data Register (MIO_BOOT_LOC_DAT). * * Local memory region 0 exists from addresses 0x00 - 0x78. * Local memory region 1 exists from addresses 0x80 - 0xf8. */ union cvmx_mio_boot_loc_adr { uint64_t u64; struct cvmx_mio_boot_loc_adr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t adr : 5; /**< Local memory address */ uint64_t reserved_0_2 : 3; #else uint64_t reserved_0_2 : 3; uint64_t adr : 5; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_boot_loc_adr_s cn30xx; struct cvmx_mio_boot_loc_adr_s cn31xx; struct cvmx_mio_boot_loc_adr_s cn38xx; struct cvmx_mio_boot_loc_adr_s cn38xxp2; struct cvmx_mio_boot_loc_adr_s cn50xx; struct cvmx_mio_boot_loc_adr_s cn52xx; struct cvmx_mio_boot_loc_adr_s cn52xxp1; struct cvmx_mio_boot_loc_adr_s cn56xx; struct cvmx_mio_boot_loc_adr_s cn56xxp1; struct cvmx_mio_boot_loc_adr_s cn58xx; struct cvmx_mio_boot_loc_adr_s cn58xxp1; struct cvmx_mio_boot_loc_adr_s cn63xx; struct cvmx_mio_boot_loc_adr_s cn63xxp1; }; typedef union cvmx_mio_boot_loc_adr cvmx_mio_boot_loc_adr_t; /** * cvmx_mio_boot_loc_cfg# * * MIO_BOOT_LOC_CFG = MIO Boot Local Region Config Register (1 per region * 2 regions) * * Contains local region enable and local region base address parameters. Each local region is 128 * bytes organized as 16 entries x 8 bytes. * * Base address specifies address bits [31:7] of the region. */ union cvmx_mio_boot_loc_cfgx { uint64_t u64; struct cvmx_mio_boot_loc_cfgx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t en : 1; /**< Local region X enable */ uint64_t reserved_28_30 : 3; uint64_t base : 25; /**< Local region X base address */ uint64_t reserved_0_2 : 3; #else uint64_t reserved_0_2 : 3; uint64_t base : 25; uint64_t reserved_28_30 : 3; uint64_t en : 1; uint64_t reserved_32_63 : 32; #endif } s; struct cvmx_mio_boot_loc_cfgx_s cn30xx; struct cvmx_mio_boot_loc_cfgx_s cn31xx; struct cvmx_mio_boot_loc_cfgx_s cn38xx; struct cvmx_mio_boot_loc_cfgx_s cn38xxp2; struct cvmx_mio_boot_loc_cfgx_s cn50xx; struct cvmx_mio_boot_loc_cfgx_s cn52xx; struct cvmx_mio_boot_loc_cfgx_s cn52xxp1; struct cvmx_mio_boot_loc_cfgx_s cn56xx; struct cvmx_mio_boot_loc_cfgx_s cn56xxp1; struct cvmx_mio_boot_loc_cfgx_s cn58xx; struct cvmx_mio_boot_loc_cfgx_s cn58xxp1; struct cvmx_mio_boot_loc_cfgx_s cn63xx; struct cvmx_mio_boot_loc_cfgx_s cn63xxp1; }; typedef union cvmx_mio_boot_loc_cfgx cvmx_mio_boot_loc_cfgx_t; /** * cvmx_mio_boot_loc_dat * * MIO_BOOT_LOC_DAT = MIO Boot Local Memory Data Register * * This is a pseudo-register that will read/write the local memory at the address specified by the MIO * Boot Local Address Register (MIO_BOOT_LOC_ADR) when accessed. */ union cvmx_mio_boot_loc_dat { uint64_t u64; struct cvmx_mio_boot_loc_dat_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t data : 64; /**< Local memory data */ #else uint64_t data : 64; #endif } s; struct cvmx_mio_boot_loc_dat_s cn30xx; struct cvmx_mio_boot_loc_dat_s cn31xx; struct cvmx_mio_boot_loc_dat_s cn38xx; struct cvmx_mio_boot_loc_dat_s cn38xxp2; struct cvmx_mio_boot_loc_dat_s cn50xx; struct cvmx_mio_boot_loc_dat_s cn52xx; struct cvmx_mio_boot_loc_dat_s cn52xxp1; struct cvmx_mio_boot_loc_dat_s cn56xx; struct cvmx_mio_boot_loc_dat_s cn56xxp1; struct cvmx_mio_boot_loc_dat_s cn58xx; struct cvmx_mio_boot_loc_dat_s cn58xxp1; struct cvmx_mio_boot_loc_dat_s cn63xx; struct cvmx_mio_boot_loc_dat_s cn63xxp1; }; typedef union cvmx_mio_boot_loc_dat cvmx_mio_boot_loc_dat_t; /** * cvmx_mio_boot_pin_defs * * MIO_BOOT_PIN_DEFS = MIO Boot Pin Defaults Register * */ union cvmx_mio_boot_pin_defs { uint64_t u64; struct cvmx_mio_boot_pin_defs_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_16_63 : 48; uint64_t ale : 1; /**< Region 0 default ALE mode */ uint64_t width : 1; /**< Region 0 default bus width */ uint64_t dmack_p2 : 1; /**< boot_dmack[2] default polarity */ uint64_t dmack_p1 : 1; /**< boot_dmack[1] default polarity */ uint64_t dmack_p0 : 1; /**< boot_dmack[0] default polarity */ uint64_t term : 2; /**< Selects default driver termination */ uint64_t nand : 1; /**< Region 0 is NAND flash */ uint64_t reserved_0_7 : 8; #else uint64_t reserved_0_7 : 8; uint64_t nand : 1; uint64_t term : 2; uint64_t dmack_p0 : 1; uint64_t dmack_p1 : 1; uint64_t dmack_p2 : 1; uint64_t width : 1; uint64_t ale : 1; uint64_t reserved_16_63 : 48; #endif } s; struct cvmx_mio_boot_pin_defs_cn52xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_16_63 : 48; uint64_t ale : 1; /**< Region 0 default ALE mode */ uint64_t width : 1; /**< Region 0 default bus width */ uint64_t reserved_13_13 : 1; uint64_t dmack_p1 : 1; /**< boot_dmack[1] default polarity */ uint64_t dmack_p0 : 1; /**< boot_dmack[0] default polarity */ uint64_t term : 2; /**< Selects default driver termination */ uint64_t nand : 1; /**< Region 0 is NAND flash */ uint64_t reserved_0_7 : 8; #else uint64_t reserved_0_7 : 8; uint64_t nand : 1; uint64_t term : 2; uint64_t dmack_p0 : 1; uint64_t dmack_p1 : 1; uint64_t reserved_13_13 : 1; uint64_t width : 1; uint64_t ale : 1; uint64_t reserved_16_63 : 48; #endif } cn52xx; struct cvmx_mio_boot_pin_defs_cn56xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_16_63 : 48; uint64_t ale : 1; /**< Region 0 default ALE mode */ uint64_t width : 1; /**< Region 0 default bus width */ uint64_t dmack_p2 : 1; /**< boot_dmack[2] default polarity */ uint64_t dmack_p1 : 1; /**< boot_dmack[1] default polarity */ uint64_t dmack_p0 : 1; /**< boot_dmack[0] default polarity */ uint64_t term : 2; /**< Selects default driver termination */ uint64_t reserved_0_8 : 9; #else uint64_t reserved_0_8 : 9; uint64_t term : 2; uint64_t dmack_p0 : 1; uint64_t dmack_p1 : 1; uint64_t dmack_p2 : 1; uint64_t width : 1; uint64_t ale : 1; uint64_t reserved_16_63 : 48; #endif } cn56xx; struct cvmx_mio_boot_pin_defs_cn52xx cn63xx; struct cvmx_mio_boot_pin_defs_cn52xx cn63xxp1; }; typedef union cvmx_mio_boot_pin_defs cvmx_mio_boot_pin_defs_t; /** * cvmx_mio_boot_reg_cfg# */ union cvmx_mio_boot_reg_cfgx { uint64_t u64; struct cvmx_mio_boot_reg_cfgx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_44_63 : 20; uint64_t dmack : 2; /**< Region X DMACK */ uint64_t tim_mult : 2; /**< Region X timing multiplier */ uint64_t rd_dly : 3; /**< Region X read sample delay */ uint64_t sam : 1; /**< Region X SAM mode */ uint64_t we_ext : 2; /**< Region X write enable count extension */ uint64_t oe_ext : 2; /**< Region X output enable count extension */ uint64_t en : 1; /**< Region X enable */ uint64_t orbit : 1; /**< Region X or bit */ uint64_t ale : 1; /**< Region X ALE mode */ uint64_t width : 1; /**< Region X bus width */ uint64_t size : 12; /**< Region X size */ uint64_t base : 16; /**< Region X base address */ #else uint64_t base : 16; uint64_t size : 12; uint64_t width : 1; uint64_t ale : 1; uint64_t orbit : 1; uint64_t en : 1; uint64_t oe_ext : 2; uint64_t we_ext : 2; uint64_t sam : 1; uint64_t rd_dly : 3; uint64_t tim_mult : 2; uint64_t dmack : 2; uint64_t reserved_44_63 : 20; #endif } s; struct cvmx_mio_boot_reg_cfgx_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_37_63 : 27; uint64_t sam : 1; /**< Region X SAM mode */ uint64_t we_ext : 2; /**< Region X write enable count extension */ uint64_t oe_ext : 2; /**< Region X output enable count extension */ uint64_t en : 1; /**< Region X enable */ uint64_t orbit : 1; /**< Region X or bit */ uint64_t ale : 1; /**< Region X ALE mode */ uint64_t width : 1; /**< Region X bus width */ uint64_t size : 12; /**< Region X size */ uint64_t base : 16; /**< Region X base address */ #else uint64_t base : 16; uint64_t size : 12; uint64_t width : 1; uint64_t ale : 1; uint64_t orbit : 1; uint64_t en : 1; uint64_t oe_ext : 2; uint64_t we_ext : 2; uint64_t sam : 1; uint64_t reserved_37_63 : 27; #endif } cn30xx; struct cvmx_mio_boot_reg_cfgx_cn30xx cn31xx; struct cvmx_mio_boot_reg_cfgx_cn38xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t en : 1; /**< Region X enable */ uint64_t orbit : 1; /**< Region X or bit */ uint64_t reserved_28_29 : 2; uint64_t size : 12; /**< Region X size */ uint64_t base : 16; /**< Region X base address */ #else uint64_t base : 16; uint64_t size : 12; uint64_t reserved_28_29 : 2; uint64_t orbit : 1; uint64_t en : 1; uint64_t reserved_32_63 : 32; #endif } cn38xx; struct cvmx_mio_boot_reg_cfgx_cn38xx cn38xxp2; struct cvmx_mio_boot_reg_cfgx_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_42_63 : 22; uint64_t tim_mult : 2; /**< Region X timing multiplier */ uint64_t rd_dly : 3; /**< Region X read sample delay */ uint64_t sam : 1; /**< Region X SAM mode */ uint64_t we_ext : 2; /**< Region X write enable count extension */ uint64_t oe_ext : 2; /**< Region X output enable count extension */ uint64_t en : 1; /**< Region X enable */ uint64_t orbit : 1; /**< Region X or bit */ uint64_t ale : 1; /**< Region X ALE mode */ uint64_t width : 1; /**< Region X bus width */ uint64_t size : 12; /**< Region X size */ uint64_t base : 16; /**< Region X base address */ #else uint64_t base : 16; uint64_t size : 12; uint64_t width : 1; uint64_t ale : 1; uint64_t orbit : 1; uint64_t en : 1; uint64_t oe_ext : 2; uint64_t we_ext : 2; uint64_t sam : 1; uint64_t rd_dly : 3; uint64_t tim_mult : 2; uint64_t reserved_42_63 : 22; #endif } cn50xx; struct cvmx_mio_boot_reg_cfgx_s cn52xx; struct cvmx_mio_boot_reg_cfgx_s cn52xxp1; struct cvmx_mio_boot_reg_cfgx_s cn56xx; struct cvmx_mio_boot_reg_cfgx_s cn56xxp1; struct cvmx_mio_boot_reg_cfgx_cn30xx cn58xx; struct cvmx_mio_boot_reg_cfgx_cn30xx cn58xxp1; struct cvmx_mio_boot_reg_cfgx_s cn63xx; struct cvmx_mio_boot_reg_cfgx_s cn63xxp1; }; typedef union cvmx_mio_boot_reg_cfgx cvmx_mio_boot_reg_cfgx_t; /** * cvmx_mio_boot_reg_tim# */ union cvmx_mio_boot_reg_timx { uint64_t u64; struct cvmx_mio_boot_reg_timx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t pagem : 1; /**< Region X page mode */ uint64_t waitm : 1; /**< Region X wait mode */ uint64_t pages : 2; /**< Region X page size */ uint64_t ale : 6; /**< Region X ALE count */ uint64_t page : 6; /**< Region X page count */ uint64_t wait : 6; /**< Region X wait count */ uint64_t pause : 6; /**< Region X pause count */ uint64_t wr_hld : 6; /**< Region X write hold count */ uint64_t rd_hld : 6; /**< Region X read hold count */ uint64_t we : 6; /**< Region X write enable count */ uint64_t oe : 6; /**< Region X output enable count */ uint64_t ce : 6; /**< Region X chip enable count */ uint64_t adr : 6; /**< Region X address count */ #else uint64_t adr : 6; uint64_t ce : 6; uint64_t oe : 6; uint64_t we : 6; uint64_t rd_hld : 6; uint64_t wr_hld : 6; uint64_t pause : 6; uint64_t wait : 6; uint64_t page : 6; uint64_t ale : 6; uint64_t pages : 2; uint64_t waitm : 1; uint64_t pagem : 1; #endif } s; struct cvmx_mio_boot_reg_timx_s cn30xx; struct cvmx_mio_boot_reg_timx_s cn31xx; struct cvmx_mio_boot_reg_timx_cn38xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t pagem : 1; /**< Region X page mode */ uint64_t waitm : 1; /**< Region X wait mode */ uint64_t pages : 2; /**< Region X page size (NOT IN PASS 1) */ uint64_t reserved_54_59 : 6; uint64_t page : 6; /**< Region X page count */ uint64_t wait : 6; /**< Region X wait count */ uint64_t pause : 6; /**< Region X pause count */ uint64_t wr_hld : 6; /**< Region X write hold count */ uint64_t rd_hld : 6; /**< Region X read hold count */ uint64_t we : 6; /**< Region X write enable count */ uint64_t oe : 6; /**< Region X output enable count */ uint64_t ce : 6; /**< Region X chip enable count */ uint64_t adr : 6; /**< Region X address count */ #else uint64_t adr : 6; uint64_t ce : 6; uint64_t oe : 6; uint64_t we : 6; uint64_t rd_hld : 6; uint64_t wr_hld : 6; uint64_t pause : 6; uint64_t wait : 6; uint64_t page : 6; uint64_t reserved_54_59 : 6; uint64_t pages : 2; uint64_t waitm : 1; uint64_t pagem : 1; #endif } cn38xx; struct cvmx_mio_boot_reg_timx_cn38xx cn38xxp2; struct cvmx_mio_boot_reg_timx_s cn50xx; struct cvmx_mio_boot_reg_timx_s cn52xx; struct cvmx_mio_boot_reg_timx_s cn52xxp1; struct cvmx_mio_boot_reg_timx_s cn56xx; struct cvmx_mio_boot_reg_timx_s cn56xxp1; struct cvmx_mio_boot_reg_timx_s cn58xx; struct cvmx_mio_boot_reg_timx_s cn58xxp1; struct cvmx_mio_boot_reg_timx_s cn63xx; struct cvmx_mio_boot_reg_timx_s cn63xxp1; }; typedef union cvmx_mio_boot_reg_timx cvmx_mio_boot_reg_timx_t; /** * cvmx_mio_boot_thr * * MIO_BOOT_THR = MIO Boot Threshold Register * * Contains MIO Boot threshold values: * * FIF_THR = Assert ncb__busy when the Boot NCB input FIFO reaches this level (not typically for * customer use). * * DMA_THR = When non-DMA accesses are pending, perform a DMA access after this value of non-DMA * accesses have completed. If set to zero, only perform a DMA access when non-DMA * accesses are not pending. */ union cvmx_mio_boot_thr { uint64_t u64; struct cvmx_mio_boot_thr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_22_63 : 42; uint64_t dma_thr : 6; /**< DMA threshold */ uint64_t reserved_14_15 : 2; uint64_t fif_cnt : 6; /**< Current NCB FIFO count */ uint64_t reserved_6_7 : 2; uint64_t fif_thr : 6; /**< NCB busy threshold */ #else uint64_t fif_thr : 6; uint64_t reserved_6_7 : 2; uint64_t fif_cnt : 6; uint64_t reserved_14_15 : 2; uint64_t dma_thr : 6; uint64_t reserved_22_63 : 42; #endif } s; struct cvmx_mio_boot_thr_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_14_63 : 50; uint64_t fif_cnt : 6; /**< Current NCB FIFO count */ uint64_t reserved_6_7 : 2; uint64_t fif_thr : 6; /**< NCB busy threshold */ #else uint64_t fif_thr : 6; uint64_t reserved_6_7 : 2; uint64_t fif_cnt : 6; uint64_t reserved_14_63 : 50; #endif } cn30xx; struct cvmx_mio_boot_thr_cn30xx cn31xx; struct cvmx_mio_boot_thr_cn30xx cn38xx; struct cvmx_mio_boot_thr_cn30xx cn38xxp2; struct cvmx_mio_boot_thr_cn30xx cn50xx; struct cvmx_mio_boot_thr_s cn52xx; struct cvmx_mio_boot_thr_s cn52xxp1; struct cvmx_mio_boot_thr_s cn56xx; struct cvmx_mio_boot_thr_s cn56xxp1; struct cvmx_mio_boot_thr_cn30xx cn58xx; struct cvmx_mio_boot_thr_cn30xx cn58xxp1; struct cvmx_mio_boot_thr_s cn63xx; struct cvmx_mio_boot_thr_s cn63xxp1; }; typedef union cvmx_mio_boot_thr cvmx_mio_boot_thr_t; /** * cvmx_mio_fus_bnk_dat# * * Notes: * The intial state of MIO_FUS_BNK_DAT* is as if bank6 was just read i.e. DAT* = fus[895:768] * */ union cvmx_mio_fus_bnk_datx { uint64_t u64; struct cvmx_mio_fus_bnk_datx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t dat : 64; /**< Efuse bank store For reads, the DAT gets the fus bank last read For write, the DAT determines which fuses to blow */ #else uint64_t dat : 64; #endif } s; struct cvmx_mio_fus_bnk_datx_s cn50xx; struct cvmx_mio_fus_bnk_datx_s cn52xx; struct cvmx_mio_fus_bnk_datx_s cn52xxp1; struct cvmx_mio_fus_bnk_datx_s cn56xx; struct cvmx_mio_fus_bnk_datx_s cn56xxp1; struct cvmx_mio_fus_bnk_datx_s cn58xx; struct cvmx_mio_fus_bnk_datx_s cn58xxp1; struct cvmx_mio_fus_bnk_datx_s cn63xx; struct cvmx_mio_fus_bnk_datx_s cn63xxp1; }; typedef union cvmx_mio_fus_bnk_datx cvmx_mio_fus_bnk_datx_t; /** * cvmx_mio_fus_dat0 */ union cvmx_mio_fus_dat0 { uint64_t u64; struct cvmx_mio_fus_dat0_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t man_info : 32; /**< Fuse information - manufacturing info [31:0] */ #else uint64_t man_info : 32; uint64_t reserved_32_63 : 32; #endif } s; struct cvmx_mio_fus_dat0_s cn30xx; struct cvmx_mio_fus_dat0_s cn31xx; struct cvmx_mio_fus_dat0_s cn38xx; struct cvmx_mio_fus_dat0_s cn38xxp2; struct cvmx_mio_fus_dat0_s cn50xx; struct cvmx_mio_fus_dat0_s cn52xx; struct cvmx_mio_fus_dat0_s cn52xxp1; struct cvmx_mio_fus_dat0_s cn56xx; struct cvmx_mio_fus_dat0_s cn56xxp1; struct cvmx_mio_fus_dat0_s cn58xx; struct cvmx_mio_fus_dat0_s cn58xxp1; struct cvmx_mio_fus_dat0_s cn63xx; struct cvmx_mio_fus_dat0_s cn63xxp1; }; typedef union cvmx_mio_fus_dat0 cvmx_mio_fus_dat0_t; /** * cvmx_mio_fus_dat1 */ union cvmx_mio_fus_dat1 { uint64_t u64; struct cvmx_mio_fus_dat1_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t man_info : 32; /**< Fuse information - manufacturing info [63:32] */ #else uint64_t man_info : 32; uint64_t reserved_32_63 : 32; #endif } s; struct cvmx_mio_fus_dat1_s cn30xx; struct cvmx_mio_fus_dat1_s cn31xx; struct cvmx_mio_fus_dat1_s cn38xx; struct cvmx_mio_fus_dat1_s cn38xxp2; struct cvmx_mio_fus_dat1_s cn50xx; struct cvmx_mio_fus_dat1_s cn52xx; struct cvmx_mio_fus_dat1_s cn52xxp1; struct cvmx_mio_fus_dat1_s cn56xx; struct cvmx_mio_fus_dat1_s cn56xxp1; struct cvmx_mio_fus_dat1_s cn58xx; struct cvmx_mio_fus_dat1_s cn58xxp1; struct cvmx_mio_fus_dat1_s cn63xx; struct cvmx_mio_fus_dat1_s cn63xxp1; }; typedef union cvmx_mio_fus_dat1 cvmx_mio_fus_dat1_t; /** * cvmx_mio_fus_dat2 * * Notes: * CHIP_ID is consumed in several places within Octeon. * * * Core COP0 ProcessorIdentification[Revision] * * Core EJTAG DeviceIdentification[Version] * * PCI_CFG02[RID] * * JTAG controller * * Note: The JTAG controller gets CHIP_ID[3:0] solely from the laser fuses. * Modification to the efuses will not change what the JTAG controller reports * for CHIP_ID. */ union cvmx_mio_fus_dat2 { uint64_t u64; struct cvmx_mio_fus_dat2_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_35_63 : 29; uint64_t dorm_crypto : 1; /**< Fuse information - Dormant Encryption enable */ uint64_t fus318 : 1; /**< Fuse information - a copy of fuse318 */ uint64_t raid_en : 1; /**< Fuse information - RAID enabled */ uint64_t reserved_30_31 : 2; uint64_t nokasu : 1; /**< Fuse information - Disable Kasumi */ uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t reserved_0_15 : 16; #else uint64_t reserved_0_15 : 16; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t nokasu : 1; uint64_t reserved_30_31 : 2; uint64_t raid_en : 1; uint64_t fus318 : 1; uint64_t dorm_crypto : 1; uint64_t reserved_35_63 : 29; #endif } s; struct cvmx_mio_fus_dat2_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_29_63 : 35; uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t pll_off : 4; /**< Fuse information - core pll offset Used to compute the base offset for the core pll. the offset will be (PLL_OFF ^ 8) Note, these fuses can only be set from laser fuse */ uint64_t reserved_1_11 : 11; uint64_t pp_dis : 1; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 1; uint64_t reserved_1_11 : 11; uint64_t pll_off : 4; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t reserved_29_63 : 35; #endif } cn30xx; struct cvmx_mio_fus_dat2_cn31xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_29_63 : 35; uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t pll_off : 4; /**< Fuse information - core pll offset Used to compute the base offset for the core pll. the offset will be (PLL_OFF ^ 8) Note, these fuses can only be set from laser fuse */ uint64_t reserved_2_11 : 10; uint64_t pp_dis : 2; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 2; uint64_t reserved_2_11 : 10; uint64_t pll_off : 4; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t reserved_29_63 : 35; #endif } cn31xx; struct cvmx_mio_fus_dat2_cn38xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_29_63 : 35; uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) (PASS2 Only) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable (PASS2 Only) */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable (PASS2 Only) */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t pp_dis : 16; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 16; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t reserved_29_63 : 35; #endif } cn38xx; struct cvmx_mio_fus_dat2_cn38xx cn38xxp2; struct cvmx_mio_fus_dat2_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_34_63 : 30; uint64_t fus318 : 1; /**< Fuse information - a copy of fuse318 */ uint64_t raid_en : 1; /**< Fuse information - RAID enabled (5020 does not have RAID co-processor) */ uint64_t reserved_30_31 : 2; uint64_t nokasu : 1; /**< Fuse information - Disable Kasumi */ uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) (5020 does not have DFA co-processor) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t reserved_2_15 : 14; uint64_t pp_dis : 2; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 2; uint64_t reserved_2_15 : 14; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t nokasu : 1; uint64_t reserved_30_31 : 2; uint64_t raid_en : 1; uint64_t fus318 : 1; uint64_t reserved_34_63 : 30; #endif } cn50xx; struct cvmx_mio_fus_dat2_cn52xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_34_63 : 30; uint64_t fus318 : 1; /**< Fuse information - a copy of fuse318 */ uint64_t raid_en : 1; /**< Fuse information - RAID enabled */ uint64_t reserved_30_31 : 2; uint64_t nokasu : 1; /**< Fuse information - Disable Kasumi */ uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t reserved_4_15 : 12; uint64_t pp_dis : 4; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 4; uint64_t reserved_4_15 : 12; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t nokasu : 1; uint64_t reserved_30_31 : 2; uint64_t raid_en : 1; uint64_t fus318 : 1; uint64_t reserved_34_63 : 30; #endif } cn52xx; struct cvmx_mio_fus_dat2_cn52xx cn52xxp1; struct cvmx_mio_fus_dat2_cn56xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_34_63 : 30; uint64_t fus318 : 1; /**< Fuse information - a copy of fuse318 */ uint64_t raid_en : 1; /**< Fuse information - RAID enabled */ uint64_t reserved_30_31 : 2; uint64_t nokasu : 1; /**< Fuse information - Disable Kasumi */ uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t reserved_12_15 : 4; uint64_t pp_dis : 12; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 12; uint64_t reserved_12_15 : 4; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t nokasu : 1; uint64_t reserved_30_31 : 2; uint64_t raid_en : 1; uint64_t fus318 : 1; uint64_t reserved_34_63 : 30; #endif } cn56xx; struct cvmx_mio_fus_dat2_cn56xx cn56xxp1; struct cvmx_mio_fus_dat2_cn58xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_30_63 : 34; uint64_t nokasu : 1; /**< Fuse information - Disable Kasumi */ uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t rst_sht : 1; /**< Fuse information - When set, use short reset count */ uint64_t bist_dis : 1; /**< Fuse information - BIST Disable */ uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t pp_dis : 16; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 16; uint64_t chip_id : 8; uint64_t bist_dis : 1; uint64_t rst_sht : 1; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t nokasu : 1; uint64_t reserved_30_63 : 34; #endif } cn58xx; struct cvmx_mio_fus_dat2_cn58xx cn58xxp1; struct cvmx_mio_fus_dat2_cn63xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_35_63 : 29; uint64_t dorm_crypto : 1; /**< Fuse information - Dormant Encryption enable */ uint64_t fus318 : 1; /**< Fuse information - a copy of fuse318 */ uint64_t raid_en : 1; /**< Fuse information - RAID enabled */ uint64_t reserved_29_31 : 3; uint64_t nodfa_cp2 : 1; /**< Fuse information - DFA Disable (CP2) */ uint64_t nomul : 1; /**< Fuse information - VMUL disable */ uint64_t nocrypto : 1; /**< Fuse information - AES/DES/HASH disable */ uint64_t reserved_24_25 : 2; uint64_t chip_id : 8; /**< Fuse information - CHIP_ID */ uint64_t reserved_6_15 : 10; uint64_t pp_dis : 6; /**< Fuse information - PP_DISABLES */ #else uint64_t pp_dis : 6; uint64_t reserved_6_15 : 10; uint64_t chip_id : 8; uint64_t reserved_24_25 : 2; uint64_t nocrypto : 1; uint64_t nomul : 1; uint64_t nodfa_cp2 : 1; uint64_t reserved_29_31 : 3; uint64_t raid_en : 1; uint64_t fus318 : 1; uint64_t dorm_crypto : 1; uint64_t reserved_35_63 : 29; #endif } cn63xx; struct cvmx_mio_fus_dat2_cn63xx cn63xxp1; }; typedef union cvmx_mio_fus_dat2 cvmx_mio_fus_dat2_t; /** * cvmx_mio_fus_dat3 */ union cvmx_mio_fus_dat3 { uint64_t u64; struct cvmx_mio_fus_dat3_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_58_63 : 6; uint64_t pll_ctl : 10; /**< Fuse information - PLL control */ uint64_t dfa_info_dte : 3; /**< Fuse information - DFA information (DTE) */ uint64_t dfa_info_clm : 4; /**< Fuse information - DFA information (Cluster mask) */ uint64_t reserved_40_40 : 1; uint64_t ema : 2; /**< Fuse information - EMA */ uint64_t efus_lck_rsv : 1; /**< Fuse information - efuse lockdown */ uint64_t efus_lck_man : 1; /**< Fuse information - efuse lockdown */ uint64_t pll_half_dis : 1; /**< Fuse information - RCLK PLL control */ uint64_t l2c_crip : 3; /**< Fuse information - L2C Cripple (1/8, 1/4, 1/2) */ uint64_t pll_div4 : 1; /**< Fuse information - PLL DIV4 mode (laser fuse only) */ uint64_t reserved_29_30 : 2; uint64_t bar2_en : 1; /**< Fuse information - BAR2 Present (when blown '1') */ uint64_t efus_lck : 1; /**< Fuse information - efuse lockdown */ uint64_t efus_ign : 1; /**< Fuse information - efuse ignore */ uint64_t nozip : 1; /**< Fuse information - ZIP disable */ uint64_t nodfa_dte : 1; /**< Fuse information - DFA Disable (DTE) */ uint64_t icache : 24; /**< Fuse information - ICACHE Hard Repair Data */ #else uint64_t icache : 24; uint64_t nodfa_dte : 1; uint64_t nozip : 1; uint64_t efus_ign : 1; uint64_t efus_lck : 1; uint64_t bar2_en : 1; uint64_t reserved_29_30 : 2; uint64_t pll_div4 : 1; uint64_t l2c_crip : 3; uint64_t pll_half_dis : 1; uint64_t efus_lck_man : 1; uint64_t efus_lck_rsv : 1; uint64_t ema : 2; uint64_t reserved_40_40 : 1; uint64_t dfa_info_clm : 4; uint64_t dfa_info_dte : 3; uint64_t pll_ctl : 10; uint64_t reserved_58_63 : 6; #endif } s; struct cvmx_mio_fus_dat3_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t pll_div4 : 1; /**< Fuse information - PLL DIV4 mode (laser fuse only) */ uint64_t reserved_29_30 : 2; uint64_t bar2_en : 1; /**< Fuse information - BAR2 Enable (when blown '1') */ uint64_t efus_lck : 1; /**< Fuse information - efuse lockdown */ uint64_t efus_ign : 1; /**< Fuse information - efuse ignore This bit only has side effects when blown in the laser fuses. It is ignore if only set in efuse store. */ uint64_t nozip : 1; /**< Fuse information - ZIP disable */ uint64_t nodfa_dte : 1; /**< Fuse information - DFA Disable (DTE) */ uint64_t icache : 24; /**< Fuse information - ICACHE Hard Repair Data */ #else uint64_t icache : 24; uint64_t nodfa_dte : 1; uint64_t nozip : 1; uint64_t efus_ign : 1; uint64_t efus_lck : 1; uint64_t bar2_en : 1; uint64_t reserved_29_30 : 2; uint64_t pll_div4 : 1; uint64_t reserved_32_63 : 32; #endif } cn30xx; struct cvmx_mio_fus_dat3_cn31xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t pll_div4 : 1; /**< Fuse information - PLL DIV4 mode (laser fuse only) */ uint64_t zip_crip : 2; /**< Fuse information - Zip Cripple (O2P Only) */ uint64_t bar2_en : 1; /**< Fuse information - BAR2 Enable (when blown '1') */ uint64_t efus_lck : 1; /**< Fuse information - efuse lockdown */ uint64_t efus_ign : 1; /**< Fuse information - efuse ignore This bit only has side effects when blown in the laser fuses. It is ignore if only set in efuse store. */ uint64_t nozip : 1; /**< Fuse information - ZIP disable */ uint64_t nodfa_dte : 1; /**< Fuse information - DFA Disable (DTE) */ uint64_t icache : 24; /**< Fuse information - ICACHE Hard Repair Data */ #else uint64_t icache : 24; uint64_t nodfa_dte : 1; uint64_t nozip : 1; uint64_t efus_ign : 1; uint64_t efus_lck : 1; uint64_t bar2_en : 1; uint64_t zip_crip : 2; uint64_t pll_div4 : 1; uint64_t reserved_32_63 : 32; #endif } cn31xx; struct cvmx_mio_fus_dat3_cn38xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_31_63 : 33; uint64_t zip_crip : 2; /**< Fuse information - Zip Cripple (PASS3 Only) */ uint64_t bar2_en : 1; /**< Fuse information - BAR2 Enable (when blown '1') (PASS2 Only) */ uint64_t efus_lck : 1; /**< Fuse information - efuse lockdown (PASS2 Only) */ uint64_t efus_ign : 1; /**< Fuse information - efuse ignore This bit only has side effects when blown in the laser fuses. It is ignore if only set in efuse store. (PASS2 Only) */ uint64_t nozip : 1; /**< Fuse information - ZIP disable (PASS2 Only) */ uint64_t nodfa_dte : 1; /**< Fuse information - DFA Disable (DTE) (PASS2 Only) */ uint64_t icache : 24; /**< Fuse information - ICACHE Hard Repair Data */ #else uint64_t icache : 24; uint64_t nodfa_dte : 1; uint64_t nozip : 1; uint64_t efus_ign : 1; uint64_t efus_lck : 1; uint64_t bar2_en : 1; uint64_t zip_crip : 2; uint64_t reserved_31_63 : 33; #endif } cn38xx; struct cvmx_mio_fus_dat3_cn38xxp2 { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_29_63 : 35; uint64_t bar2_en : 1; /**< Fuse information - BAR2 Enable (when blown '1') (PASS2 Only) */ uint64_t efus_lck : 1; /**< Fuse information - efuse lockdown (PASS2 Only) */ uint64_t efus_ign : 1; /**< Fuse information - efuse ignore This bit only has side effects when blown in the laser fuses. It is ignore if only set in efuse store. (PASS2 Only) */ uint64_t nozip : 1; /**< Fuse information - ZIP disable (PASS2 Only) */ uint64_t nodfa_dte : 1; /**< Fuse information - DFA Disable (DTE) (PASS2 Only) */ uint64_t icache : 24; /**< Fuse information - ICACHE Hard Repair Data */ #else uint64_t icache : 24; uint64_t nodfa_dte : 1; uint64_t nozip : 1; uint64_t efus_ign : 1; uint64_t efus_lck : 1; uint64_t bar2_en : 1; uint64_t reserved_29_63 : 35; #endif } cn38xxp2; struct cvmx_mio_fus_dat3_cn38xx cn50xx; struct cvmx_mio_fus_dat3_cn38xx cn52xx; struct cvmx_mio_fus_dat3_cn38xx cn52xxp1; struct cvmx_mio_fus_dat3_cn38xx cn56xx; struct cvmx_mio_fus_dat3_cn38xx cn56xxp1; struct cvmx_mio_fus_dat3_cn38xx cn58xx; struct cvmx_mio_fus_dat3_cn38xx cn58xxp1; struct cvmx_mio_fus_dat3_cn63xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_58_63 : 6; uint64_t pll_ctl : 10; /**< Fuse information - PLL control */ uint64_t dfa_info_dte : 3; /**< Fuse information - DFA information (DTE) */ uint64_t dfa_info_clm : 4; /**< Fuse information - DFA information (Cluster mask) */ uint64_t reserved_40_40 : 1; uint64_t ema : 2; /**< Fuse information - EMA */ uint64_t efus_lck_rsv : 1; /**< Fuse information - efuse lockdown */ uint64_t efus_lck_man : 1; /**< Fuse information - efuse lockdown */ uint64_t pll_half_dis : 1; /**< Fuse information - RCLK PLL control */ uint64_t l2c_crip : 3; /**< Fuse information - L2C Cripple (1/8, 1/4, 1/2) */ uint64_t reserved_31_31 : 1; uint64_t zip_info : 2; /**< Fuse information - Zip information */ uint64_t bar2_en : 1; /**< Fuse information - BAR2 Present (when blown '1') */ uint64_t efus_lck : 1; /**< Fuse information - efuse lockdown */ uint64_t efus_ign : 1; /**< Fuse information - efuse ignore */ uint64_t nozip : 1; /**< Fuse information - ZIP disable */ uint64_t nodfa_dte : 1; /**< Fuse information - DFA Disable (DTE) */ uint64_t reserved_0_23 : 24; #else uint64_t reserved_0_23 : 24; uint64_t nodfa_dte : 1; uint64_t nozip : 1; uint64_t efus_ign : 1; uint64_t efus_lck : 1; uint64_t bar2_en : 1; uint64_t zip_info : 2; uint64_t reserved_31_31 : 1; uint64_t l2c_crip : 3; uint64_t pll_half_dis : 1; uint64_t efus_lck_man : 1; uint64_t efus_lck_rsv : 1; uint64_t ema : 2; uint64_t reserved_40_40 : 1; uint64_t dfa_info_clm : 4; uint64_t dfa_info_dte : 3; uint64_t pll_ctl : 10; uint64_t reserved_58_63 : 6; #endif } cn63xx; struct cvmx_mio_fus_dat3_cn63xx cn63xxp1; }; typedef union cvmx_mio_fus_dat3 cvmx_mio_fus_dat3_t; /** * cvmx_mio_fus_ema */ union cvmx_mio_fus_ema { uint64_t u64; struct cvmx_mio_fus_ema_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_7_63 : 57; uint64_t eff_ema : 3; /**< Reserved */ uint64_t reserved_3_3 : 1; uint64_t ema : 3; /**< Reserved */ #else uint64_t ema : 3; uint64_t reserved_3_3 : 1; uint64_t eff_ema : 3; uint64_t reserved_7_63 : 57; #endif } s; struct cvmx_mio_fus_ema_s cn50xx; struct cvmx_mio_fus_ema_s cn52xx; struct cvmx_mio_fus_ema_s cn52xxp1; struct cvmx_mio_fus_ema_s cn56xx; struct cvmx_mio_fus_ema_s cn56xxp1; struct cvmx_mio_fus_ema_cn58xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t ema : 2; /**< EMA Settings */ #else uint64_t ema : 2; uint64_t reserved_2_63 : 62; #endif } cn58xx; struct cvmx_mio_fus_ema_cn58xx cn58xxp1; struct cvmx_mio_fus_ema_s cn63xx; struct cvmx_mio_fus_ema_s cn63xxp1; }; typedef union cvmx_mio_fus_ema cvmx_mio_fus_ema_t; /** * cvmx_mio_fus_pdf */ union cvmx_mio_fus_pdf { uint64_t u64; struct cvmx_mio_fus_pdf_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t pdf : 64; /**< Fuse information - Product Definition Field */ #else uint64_t pdf : 64; #endif } s; struct cvmx_mio_fus_pdf_s cn50xx; struct cvmx_mio_fus_pdf_s cn52xx; struct cvmx_mio_fus_pdf_s cn52xxp1; struct cvmx_mio_fus_pdf_s cn56xx; struct cvmx_mio_fus_pdf_s cn56xxp1; struct cvmx_mio_fus_pdf_s cn58xx; struct cvmx_mio_fus_pdf_s cn63xx; struct cvmx_mio_fus_pdf_s cn63xxp1; }; typedef union cvmx_mio_fus_pdf cvmx_mio_fus_pdf_t; /** * cvmx_mio_fus_pll * * Notes: * The core clkout postscaler should be placed in reset at least 10 ref clocks prior to changing * the core clkout select. The core clkout postscaler should remain under reset for at least 10 * ref clocks after the core clkout select changes. * * The pnr clkout postscaler should be placed in reset at least 10 ref clocks prior to changing * the pnr clkout select. The pnr clkout postscaler should remain under reset for at least 10 * ref clocks after the pnr clkout select changes. */ union cvmx_mio_fus_pll { uint64_t u64; struct cvmx_mio_fus_pll_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t c_cout_rst : 1; /**< Core clkout postscaler reset */ uint64_t c_cout_sel : 2; /**< Core clkout select (0=RCLK,1=PS output,2=PLL output, 3=GND) | $PR */ uint64_t pnr_cout_rst : 1; /**< PNR clkout postscaler reset */ uint64_t pnr_cout_sel : 2; /**< PNR clkout select (0=SCLK,1=PS output,2=PLL output, 3=GND) | $PR */ uint64_t rfslip : 1; /**< Reserved */ uint64_t fbslip : 1; /**< Reserved */ #else uint64_t fbslip : 1; uint64_t rfslip : 1; uint64_t pnr_cout_sel : 2; uint64_t pnr_cout_rst : 1; uint64_t c_cout_sel : 2; uint64_t c_cout_rst : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_fus_pll_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t rfslip : 1; /**< PLL reference clock slip */ uint64_t fbslip : 1; /**< PLL feedback clock slip */ #else uint64_t fbslip : 1; uint64_t rfslip : 1; uint64_t reserved_2_63 : 62; #endif } cn50xx; struct cvmx_mio_fus_pll_cn50xx cn52xx; struct cvmx_mio_fus_pll_cn50xx cn52xxp1; struct cvmx_mio_fus_pll_cn50xx cn56xx; struct cvmx_mio_fus_pll_cn50xx cn56xxp1; struct cvmx_mio_fus_pll_cn50xx cn58xx; struct cvmx_mio_fus_pll_cn50xx cn58xxp1; struct cvmx_mio_fus_pll_s cn63xx; struct cvmx_mio_fus_pll_s cn63xxp1; }; typedef union cvmx_mio_fus_pll cvmx_mio_fus_pll_t; /** * cvmx_mio_fus_prog * * DON'T PUT IN HRM* * * * Notes: * This CSR is not present in the HRM. * * To write a bank of fuses, SW must set MIO_FUS_WADR[ADDR] to the bank to be * programmed and then set each bit within MIO_FUS_BNK_DATX to indicate which * fuses to blow. Once ADDR, and DAT are setup, SW can write to * MIO_FUS_PROG[PROG] to start the bank write and poll on PROG. Once PROG is * clear, the bank write is complete. * * A soft blow is still subject to lockdown fuses. After a soft/warm reset, the * chip will behave as though the fuses were actually blown. A cold reset restores * the actual fuse valuse. */ union cvmx_mio_fus_prog { uint64_t u64; struct cvmx_mio_fus_prog_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t soft : 1; /**< When set with PROG, causes only the local storeage to change. Will not really blow any fuses. HW will clear when the program operation is complete */ uint64_t prog : 1; /**< Blow the fuse bank SW will set PROG, and then the HW will clear when the program operation is complete */ #else uint64_t prog : 1; uint64_t soft : 1; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_fus_prog_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t prog : 1; /**< Blow the fuse SW will set PROG, hold it for 10us, then clear it */ #else uint64_t prog : 1; uint64_t reserved_1_63 : 63; #endif } cn30xx; struct cvmx_mio_fus_prog_cn30xx cn31xx; struct cvmx_mio_fus_prog_cn30xx cn38xx; struct cvmx_mio_fus_prog_cn30xx cn38xxp2; struct cvmx_mio_fus_prog_cn30xx cn50xx; struct cvmx_mio_fus_prog_cn30xx cn52xx; struct cvmx_mio_fus_prog_cn30xx cn52xxp1; struct cvmx_mio_fus_prog_cn30xx cn56xx; struct cvmx_mio_fus_prog_cn30xx cn56xxp1; struct cvmx_mio_fus_prog_cn30xx cn58xx; struct cvmx_mio_fus_prog_cn30xx cn58xxp1; struct cvmx_mio_fus_prog_s cn63xx; struct cvmx_mio_fus_prog_s cn63xxp1; }; typedef union cvmx_mio_fus_prog cvmx_mio_fus_prog_t; /** * cvmx_mio_fus_prog_times * * DON'T PUT IN HRM* * * * Notes: * This CSR is not present in the HRM. * * All values must be > 0 for correct electrical operation. * * IFB fuses are 0..1791 * L6G fuses are 1792 to 2047 * * The reset values are for IFB fuses for ref_clk of 100MHZ */ union cvmx_mio_fus_prog_times { uint64_t u64; struct cvmx_mio_fus_prog_times_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_35_63 : 29; uint64_t vgate_pin : 1; /**< efuse vgate pin (L6G) */ uint64_t fsrc_pin : 1; /**< efuse fsource pin (L6G) */ uint64_t prog_pin : 1; /**< efuse program pin (IFB) */ uint64_t reserved_6_31 : 26; uint64_t setup : 6; /**< efuse timing param SETUP = (tWRS/refclk period)-1 For IFB: tWRS = 20ns For L6G: tWRS = 20ns */ #else uint64_t setup : 6; uint64_t reserved_6_31 : 26; uint64_t prog_pin : 1; uint64_t fsrc_pin : 1; uint64_t vgate_pin : 1; uint64_t reserved_35_63 : 29; #endif } s; struct cvmx_mio_fus_prog_times_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_33_63 : 31; uint64_t prog_pin : 1; /**< efuse program pin */ uint64_t out : 8; /**< efuse timing param (ref_clks to delay 10ns) */ uint64_t sclk_lo : 4; /**< efuse timing param (ref_clks to delay 5ns) */ uint64_t sclk_hi : 12; /**< efuse timing param (ref_clks to delay 1000ns) */ uint64_t setup : 8; /**< efuse timing param (ref_clks to delay 10ns) */ #else uint64_t setup : 8; uint64_t sclk_hi : 12; uint64_t sclk_lo : 4; uint64_t out : 8; uint64_t prog_pin : 1; uint64_t reserved_33_63 : 31; #endif } cn50xx; struct cvmx_mio_fus_prog_times_cn50xx cn52xx; struct cvmx_mio_fus_prog_times_cn50xx cn52xxp1; struct cvmx_mio_fus_prog_times_cn50xx cn56xx; struct cvmx_mio_fus_prog_times_cn50xx cn56xxp1; struct cvmx_mio_fus_prog_times_cn50xx cn58xx; struct cvmx_mio_fus_prog_times_cn50xx cn58xxp1; struct cvmx_mio_fus_prog_times_cn63xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_35_63 : 29; uint64_t vgate_pin : 1; /**< efuse vgate pin (L6G) */ uint64_t fsrc_pin : 1; /**< efuse fsource pin (L6G) */ uint64_t prog_pin : 1; /**< efuse program pin (IFB) */ uint64_t out : 7; /**< efuse timing param OUT = (tOUT/refclk period)-1 For IFB: tOUT = 20ns For L6G: tOUT = 20ns */ uint64_t sclk_lo : 4; /**< efuse timing param SCLK_LO=(tSLO/refclk period)-1 For IFB: tSLO = 20ns For L6G: tSLO = 20ns */ uint64_t sclk_hi : 15; /**< efuse timing param ***NOTE: Pass 1.x reset value is 20000 SCLK_HI=(tSHI/refclk period)-1 For IFB: tSHI = 200us For L6G: tSHI = 25us */ uint64_t setup : 6; /**< efuse timing param SETUP = (tWRS/refclk period)-1 For IFB: tWRS = 20ns For L6G: tWRS = 20ns */ #else uint64_t setup : 6; uint64_t sclk_hi : 15; uint64_t sclk_lo : 4; uint64_t out : 7; uint64_t prog_pin : 1; uint64_t fsrc_pin : 1; uint64_t vgate_pin : 1; uint64_t reserved_35_63 : 29; #endif } cn63xx; struct cvmx_mio_fus_prog_times_cn63xx cn63xxp1; }; typedef union cvmx_mio_fus_prog_times cvmx_mio_fus_prog_times_t; /** * cvmx_mio_fus_rcmd * * Notes: * To read an efuse, SW writes MIO_FUS_RCMD[ADDR,PEND] with the byte address of * the fuse in question, then SW can poll MIO_FUS_RCMD[PEND]. When PEND is * clear, then MIO_FUS_RCMD[DAT] is valid. In addition, if the efuse read went * to the efuse banks (eg. ((ADDR/16) not [0,1,7]) || EFUSE) SW can read * MIO_FUS_BNK_DATX which contains all 128 fuses in the bank associated in * ADDR. */ union cvmx_mio_fus_rcmd { uint64_t u64; struct cvmx_mio_fus_rcmd_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_24_63 : 40; uint64_t dat : 8; /**< 8bits of fuse data */ uint64_t reserved_13_15 : 3; uint64_t pend : 1; /**< SW sets this bit on a write to start FUSE read operation. HW clears when read is complete and the DAT is valid */ uint64_t reserved_9_11 : 3; uint64_t efuse : 1; /**< When set, return data from the efuse storage rather than the local storage */ uint64_t addr : 8; /**< The byte address of the fuse to read */ #else uint64_t addr : 8; uint64_t efuse : 1; uint64_t reserved_9_11 : 3; uint64_t pend : 1; uint64_t reserved_13_15 : 3; uint64_t dat : 8; uint64_t reserved_24_63 : 40; #endif } s; struct cvmx_mio_fus_rcmd_cn30xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_24_63 : 40; uint64_t dat : 8; /**< 8bits of fuse data */ uint64_t reserved_13_15 : 3; uint64_t pend : 1; /**< SW sets this bit on a write to start FUSE read operation. HW clears when read is complete and the DAT is valid */ uint64_t reserved_9_11 : 3; uint64_t efuse : 1; /**< When set, return data from the efuse storage rather than the local storage for the 320 HW fuses */ uint64_t reserved_7_7 : 1; uint64_t addr : 7; /**< The byte address of the fuse to read */ #else uint64_t addr : 7; uint64_t reserved_7_7 : 1; uint64_t efuse : 1; uint64_t reserved_9_11 : 3; uint64_t pend : 1; uint64_t reserved_13_15 : 3; uint64_t dat : 8; uint64_t reserved_24_63 : 40; #endif } cn30xx; struct cvmx_mio_fus_rcmd_cn30xx cn31xx; struct cvmx_mio_fus_rcmd_cn30xx cn38xx; struct cvmx_mio_fus_rcmd_cn30xx cn38xxp2; struct cvmx_mio_fus_rcmd_cn30xx cn50xx; struct cvmx_mio_fus_rcmd_s cn52xx; struct cvmx_mio_fus_rcmd_s cn52xxp1; struct cvmx_mio_fus_rcmd_s cn56xx; struct cvmx_mio_fus_rcmd_s cn56xxp1; struct cvmx_mio_fus_rcmd_cn30xx cn58xx; struct cvmx_mio_fus_rcmd_cn30xx cn58xxp1; struct cvmx_mio_fus_rcmd_s cn63xx; struct cvmx_mio_fus_rcmd_s cn63xxp1; }; typedef union cvmx_mio_fus_rcmd cvmx_mio_fus_rcmd_t; /** * cvmx_mio_fus_read_times * * Notes: * IFB fuses are 0..1791 * L6G fuses are 1792 to 2047 * * The reset values are for IFB fuses for refclk up to 100MHZ when core PLL is enagaged * The reset values are for IFB fuses for refclk up to 500MHZ when core PLL is not enagaged * * If any of the formulas above result in a value less than zero, the corresponding * timing parameter should be set to zero. * * Prior to issuing a read to the fuse banks (via. MIO_FUS_RCMD), this register * should be written with the timing parameters which correspond to the fuse bank type (IFB vs L6G) * that will be read. * * This register should not be written while MIO_FUS_RCMD[PEND]=1. */ union cvmx_mio_fus_read_times { uint64_t u64; struct cvmx_mio_fus_read_times_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_26_63 : 38; uint64_t sch : 4; /**< Hold CS for (SCH+1) refclks after FSET desserts SCH = (tSCH/refclk period)-1 For IFB: tSCH = 160ns For L6G: tSCH = 10ns */ uint64_t fsh : 4; /**< Hold FSET for (FSH+1) refclks after PRCHG deasserts FSH = (tFSH/refclk period)-1 For IFB: tFSH = 160ns For L6G: tFSH = 10ns */ uint64_t prh : 4; /**< Assert PRCHG (PRH+1) refclks after SIGDEV deasserts PRH = (tPRH/refclk period)-1 For IFB: tPRH = 70ns For L6G: tPRH = 10ns */ uint64_t sdh : 4; /**< Hold SIGDEV for (SDH+1) refclks after FSET asserts SDH = (tSDH/refclk period)-1 For IFB: tPRH = 10ns For L6G: tPRH = 10ns */ uint64_t setup : 10; /**< Assert CS for (SETUP+1) refclks before asserting SIGDEV, FSET, or PRCHG SETUP=(tRDS/refclk period)-1 For IFB: tRDS = 10000ns For L6G: tRDS = max(tSCS,tSDS,tPRS) where tSCS = 10ns tSDS = 10ns tPRS = 10ns */ #else uint64_t setup : 10; uint64_t sdh : 4; uint64_t prh : 4; uint64_t fsh : 4; uint64_t sch : 4; uint64_t reserved_26_63 : 38; #endif } s; struct cvmx_mio_fus_read_times_s cn63xx; struct cvmx_mio_fus_read_times_s cn63xxp1; }; typedef union cvmx_mio_fus_read_times cvmx_mio_fus_read_times_t; /** * cvmx_mio_fus_repair_res0 */ union cvmx_mio_fus_repair_res0 { uint64_t u64; struct cvmx_mio_fus_repair_res0_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_55_63 : 9; uint64_t too_many : 1; /**< Too many defects */ uint64_t repair2 : 18; /**< BISR Results */ uint64_t repair1 : 18; /**< BISR Results */ uint64_t repair0 : 18; /**< BISR Results */ #else uint64_t repair0 : 18; uint64_t repair1 : 18; uint64_t repair2 : 18; uint64_t too_many : 1; uint64_t reserved_55_63 : 9; #endif } s; struct cvmx_mio_fus_repair_res0_s cn63xx; struct cvmx_mio_fus_repair_res0_s cn63xxp1; }; typedef union cvmx_mio_fus_repair_res0 cvmx_mio_fus_repair_res0_t; /** * cvmx_mio_fus_repair_res1 */ union cvmx_mio_fus_repair_res1 { uint64_t u64; struct cvmx_mio_fus_repair_res1_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_54_63 : 10; uint64_t repair5 : 18; /**< BISR Results */ uint64_t repair4 : 18; /**< BISR Results */ uint64_t repair3 : 18; /**< BISR Results */ #else uint64_t repair3 : 18; uint64_t repair4 : 18; uint64_t repair5 : 18; uint64_t reserved_54_63 : 10; #endif } s; struct cvmx_mio_fus_repair_res1_s cn63xx; struct cvmx_mio_fus_repair_res1_s cn63xxp1; }; typedef union cvmx_mio_fus_repair_res1 cvmx_mio_fus_repair_res1_t; /** * cvmx_mio_fus_repair_res2 */ union cvmx_mio_fus_repair_res2 { uint64_t u64; struct cvmx_mio_fus_repair_res2_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_18_63 : 46; uint64_t repair6 : 18; /**< BISR Results */ #else uint64_t repair6 : 18; uint64_t reserved_18_63 : 46; #endif } s; struct cvmx_mio_fus_repair_res2_s cn63xx; struct cvmx_mio_fus_repair_res2_s cn63xxp1; }; typedef union cvmx_mio_fus_repair_res2 cvmx_mio_fus_repair_res2_t; /** * cvmx_mio_fus_spr_repair_res * * Notes: * Pass3 Only * */ union cvmx_mio_fus_spr_repair_res { uint64_t u64; struct cvmx_mio_fus_spr_repair_res_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_42_63 : 22; uint64_t repair2 : 14; /**< Reserved (see MIO_FUS_REPAIR_RES*) */ uint64_t repair1 : 14; /**< Reserved (see MIO_FUS_REPAIR_RES*) */ uint64_t repair0 : 14; /**< Reserved (see MIO_FUS_REPAIR_RES*) */ #else uint64_t repair0 : 14; uint64_t repair1 : 14; uint64_t repair2 : 14; uint64_t reserved_42_63 : 22; #endif } s; struct cvmx_mio_fus_spr_repair_res_s cn30xx; struct cvmx_mio_fus_spr_repair_res_s cn31xx; struct cvmx_mio_fus_spr_repair_res_s cn38xx; struct cvmx_mio_fus_spr_repair_res_s cn50xx; struct cvmx_mio_fus_spr_repair_res_s cn52xx; struct cvmx_mio_fus_spr_repair_res_s cn52xxp1; struct cvmx_mio_fus_spr_repair_res_s cn56xx; struct cvmx_mio_fus_spr_repair_res_s cn56xxp1; struct cvmx_mio_fus_spr_repair_res_s cn58xx; struct cvmx_mio_fus_spr_repair_res_s cn58xxp1; struct cvmx_mio_fus_spr_repair_res_s cn63xx; struct cvmx_mio_fus_spr_repair_res_s cn63xxp1; }; typedef union cvmx_mio_fus_spr_repair_res cvmx_mio_fus_spr_repair_res_t; /** * cvmx_mio_fus_spr_repair_sum * * Notes: * Pass3 Only * */ union cvmx_mio_fus_spr_repair_sum { uint64_t u64; struct cvmx_mio_fus_spr_repair_sum_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t too_many : 1; /**< Reserved (see MIO_FUS_REPAIR_RES*) */ #else uint64_t too_many : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_fus_spr_repair_sum_s cn30xx; struct cvmx_mio_fus_spr_repair_sum_s cn31xx; struct cvmx_mio_fus_spr_repair_sum_s cn38xx; struct cvmx_mio_fus_spr_repair_sum_s cn50xx; struct cvmx_mio_fus_spr_repair_sum_s cn52xx; struct cvmx_mio_fus_spr_repair_sum_s cn52xxp1; struct cvmx_mio_fus_spr_repair_sum_s cn56xx; struct cvmx_mio_fus_spr_repair_sum_s cn56xxp1; struct cvmx_mio_fus_spr_repair_sum_s cn58xx; struct cvmx_mio_fus_spr_repair_sum_s cn58xxp1; struct cvmx_mio_fus_spr_repair_sum_s cn63xx; struct cvmx_mio_fus_spr_repair_sum_s cn63xxp1; }; typedef union cvmx_mio_fus_spr_repair_sum cvmx_mio_fus_spr_repair_sum_t; /** * cvmx_mio_fus_unlock */ union cvmx_mio_fus_unlock { uint64_t u64; struct cvmx_mio_fus_unlock_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_24_63 : 40; uint64_t key : 24; /**< When set to the typical value, allows SW to program the efuses */ #else uint64_t key : 24; uint64_t reserved_24_63 : 40; #endif } s; struct cvmx_mio_fus_unlock_s cn30xx; struct cvmx_mio_fus_unlock_s cn31xx; }; typedef union cvmx_mio_fus_unlock cvmx_mio_fus_unlock_t; /** * cvmx_mio_fus_wadr */ union cvmx_mio_fus_wadr { uint64_t u64; struct cvmx_mio_fus_wadr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t addr : 10; /**< Which of the banks of 128 fuses to blow */ #else uint64_t addr : 10; uint64_t reserved_10_63 : 54; #endif } s; struct cvmx_mio_fus_wadr_s cn30xx; struct cvmx_mio_fus_wadr_s cn31xx; struct cvmx_mio_fus_wadr_s cn38xx; struct cvmx_mio_fus_wadr_s cn38xxp2; struct cvmx_mio_fus_wadr_cn50xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t addr : 2; /**< Which of the four banks of 256 fuses to blow */ #else uint64_t addr : 2; uint64_t reserved_2_63 : 62; #endif } cn50xx; struct cvmx_mio_fus_wadr_cn52xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_3_63 : 61; uint64_t addr : 3; /**< Which of the four banks of 256 fuses to blow */ #else uint64_t addr : 3; uint64_t reserved_3_63 : 61; #endif } cn52xx; struct cvmx_mio_fus_wadr_cn52xx cn52xxp1; struct cvmx_mio_fus_wadr_cn52xx cn56xx; struct cvmx_mio_fus_wadr_cn52xx cn56xxp1; struct cvmx_mio_fus_wadr_cn50xx cn58xx; struct cvmx_mio_fus_wadr_cn50xx cn58xxp1; struct cvmx_mio_fus_wadr_cn63xx { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_4_63 : 60; uint64_t addr : 4; /**< Which of the banks of 128 fuses to blow */ #else uint64_t addr : 4; uint64_t reserved_4_63 : 60; #endif } cn63xx; struct cvmx_mio_fus_wadr_cn63xx cn63xxp1; }; typedef union cvmx_mio_fus_wadr cvmx_mio_fus_wadr_t; /** * cvmx_mio_gpio_comp * * MIO_GPIO_COMP = MIO GPIO Compensation Register * */ union cvmx_mio_gpio_comp { uint64_t u64; struct cvmx_mio_gpio_comp_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_12_63 : 52; uint64_t pctl : 6; /**< GPIO bus PCTL */ uint64_t nctl : 6; /**< GPIO bus NCTL */ #else uint64_t nctl : 6; uint64_t pctl : 6; uint64_t reserved_12_63 : 52; #endif } s; struct cvmx_mio_gpio_comp_s cn63xx; struct cvmx_mio_gpio_comp_s cn63xxp1; }; typedef union cvmx_mio_gpio_comp cvmx_mio_gpio_comp_t; /** * cvmx_mio_ndf_dma_cfg * * MIO_NDF_DMA_CFG = MIO NAND Flash DMA Config Register * * SIZE is specified in number of 64 bit transfers (encoded in -1 notation). * * ADR must be 64 bit aligned. */ union cvmx_mio_ndf_dma_cfg { uint64_t u64; struct cvmx_mio_ndf_dma_cfg_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t en : 1; /**< DMA Engine enable */ uint64_t rw : 1; /**< DMA Engine R/W bit (0 = read, 1 = write) */ uint64_t clr : 1; /**< DMA Engine clear EN on device terminated burst */ uint64_t reserved_60_60 : 1; uint64_t swap32 : 1; /**< DMA Engine 32 bit swap */ uint64_t swap16 : 1; /**< DMA Engine 16 bit swap */ uint64_t swap8 : 1; /**< DMA Engine 8 bit swap */ uint64_t endian : 1; /**< DMA Engine NCB endian mode (0 = big, 1 = little) */ uint64_t size : 20; /**< DMA Engine size */ uint64_t adr : 36; /**< DMA Engine address */ #else uint64_t adr : 36; uint64_t size : 20; uint64_t endian : 1; uint64_t swap8 : 1; uint64_t swap16 : 1; uint64_t swap32 : 1; uint64_t reserved_60_60 : 1; uint64_t clr : 1; uint64_t rw : 1; uint64_t en : 1; #endif } s; struct cvmx_mio_ndf_dma_cfg_s cn52xx; struct cvmx_mio_ndf_dma_cfg_s cn63xx; struct cvmx_mio_ndf_dma_cfg_s cn63xxp1; }; typedef union cvmx_mio_ndf_dma_cfg cvmx_mio_ndf_dma_cfg_t; /** * cvmx_mio_ndf_dma_int * * MIO_NDF_DMA_INT = MIO NAND Flash DMA Interrupt Register * */ union cvmx_mio_ndf_dma_int { uint64_t u64; struct cvmx_mio_ndf_dma_int_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t done : 1; /**< DMA Engine request completion interrupt */ #else uint64_t done : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_ndf_dma_int_s cn52xx; struct cvmx_mio_ndf_dma_int_s cn63xx; struct cvmx_mio_ndf_dma_int_s cn63xxp1; }; typedef union cvmx_mio_ndf_dma_int cvmx_mio_ndf_dma_int_t; /** * cvmx_mio_ndf_dma_int_en * * MIO_NDF_DMA_INT_EN = MIO NAND Flash DMA Interrupt Enable Register * */ union cvmx_mio_ndf_dma_int_en { uint64_t u64; struct cvmx_mio_ndf_dma_int_en_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t done : 1; /**< DMA Engine request completion interrupt enable */ #else uint64_t done : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_ndf_dma_int_en_s cn52xx; struct cvmx_mio_ndf_dma_int_en_s cn63xx; struct cvmx_mio_ndf_dma_int_en_s cn63xxp1; }; typedef union cvmx_mio_ndf_dma_int_en cvmx_mio_ndf_dma_int_en_t; /** * cvmx_mio_pll_ctl */ union cvmx_mio_pll_ctl { uint64_t u64; struct cvmx_mio_pll_ctl_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_5_63 : 59; uint64_t bw_ctl : 5; /**< Core PLL bandwidth control */ #else uint64_t bw_ctl : 5; uint64_t reserved_5_63 : 59; #endif } s; struct cvmx_mio_pll_ctl_s cn30xx; struct cvmx_mio_pll_ctl_s cn31xx; }; typedef union cvmx_mio_pll_ctl cvmx_mio_pll_ctl_t; /** * cvmx_mio_pll_setting */ union cvmx_mio_pll_setting { uint64_t u64; struct cvmx_mio_pll_setting_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_17_63 : 47; uint64_t setting : 17; /**< Core PLL setting */ #else uint64_t setting : 17; uint64_t reserved_17_63 : 47; #endif } s; struct cvmx_mio_pll_setting_s cn30xx; struct cvmx_mio_pll_setting_s cn31xx; }; typedef union cvmx_mio_pll_setting cvmx_mio_pll_setting_t; /** * cvmx_mio_ptp_clock_cfg * * MIO_PTP_CLOCK_CFG = Configuration * */ union cvmx_mio_ptp_clock_cfg { uint64_t u64; struct cvmx_mio_ptp_clock_cfg_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_24_63 : 40; uint64_t evcnt_in : 6; /**< Source for event counter input 0x00-0x0f : GPIO[EVCNT_IN[3:0]] 0x10 : QLM0_REF_CLK 0x11 : QLM1_REF_CLK 0x12 : QLM2_REF_CLK 0x13-0x3f : Reserved */ uint64_t evcnt_edge : 1; /**< Event counter input edge 0 = falling edge 1 = rising edge */ uint64_t evcnt_en : 1; /**< Enable event counter */ uint64_t tstmp_in : 6; /**< Source for timestamp input 0x00-0x0f : GPIO[TSTMP_IN[3:0]] 0x10 : QLM0_REF_CLK 0x11 : QLM1_REF_CLK 0x12 : QLM2_REF_CLK 0x13-0x3f : Reserved */ uint64_t tstmp_edge : 1; /**< External timestamp input edge 0 = falling edge 1 = rising edge */ uint64_t tstmp_en : 1; /**< Enable external timestamp */ uint64_t ext_clk_in : 6; /**< Source for external clock 0x00-0x0f : GPIO[EXT_CLK_IN[3:0]] 0x10 : QLM0_REF_CLK 0x11 : QLM1_REF_CLK 0x12 : QLM2_REF_CLK 0x13-0x3f : Reserved */ uint64_t ext_clk_en : 1; /**< Use positive edge of external clock */ uint64_t ptp_en : 1; /**< Enable PTP Module */ #else uint64_t ptp_en : 1; uint64_t ext_clk_en : 1; uint64_t ext_clk_in : 6; uint64_t tstmp_en : 1; uint64_t tstmp_edge : 1; uint64_t tstmp_in : 6; uint64_t evcnt_en : 1; uint64_t evcnt_edge : 1; uint64_t evcnt_in : 6; uint64_t reserved_24_63 : 40; #endif } s; struct cvmx_mio_ptp_clock_cfg_s cn63xx; struct cvmx_mio_ptp_clock_cfg_s cn63xxp1; }; typedef union cvmx_mio_ptp_clock_cfg cvmx_mio_ptp_clock_cfg_t; /** * cvmx_mio_ptp_clock_comp * * MIO_PTP_CLOCK_COMP = Compensator * */ union cvmx_mio_ptp_clock_comp { uint64_t u64; struct cvmx_mio_ptp_clock_comp_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t nanosec : 32; /**< Nanoseconds */ uint64_t frnanosec : 32; /**< Fractions of Nanoseconds */ #else uint64_t frnanosec : 32; uint64_t nanosec : 32; #endif } s; struct cvmx_mio_ptp_clock_comp_s cn63xx; struct cvmx_mio_ptp_clock_comp_s cn63xxp1; }; typedef union cvmx_mio_ptp_clock_comp cvmx_mio_ptp_clock_comp_t; /** * cvmx_mio_ptp_clock_hi * * MIO_PTP_CLOCK_HI = Hi bytes of CLOCK * * Writes to MIO_PTP_CLOCK_HI also clear MIO_PTP_CLOCK_LO. To update all 96 bits, write MIO_PTP_CLOCK_HI followed * by MIO_PTP_CLOCK_LO */ union cvmx_mio_ptp_clock_hi { uint64_t u64; struct cvmx_mio_ptp_clock_hi_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t nanosec : 64; /**< Nanoseconds */ #else uint64_t nanosec : 64; #endif } s; struct cvmx_mio_ptp_clock_hi_s cn63xx; struct cvmx_mio_ptp_clock_hi_s cn63xxp1; }; typedef union cvmx_mio_ptp_clock_hi cvmx_mio_ptp_clock_hi_t; /** * cvmx_mio_ptp_clock_lo * * MIO_PTP_CLOCK_LO = Lo bytes of CLOCK * */ union cvmx_mio_ptp_clock_lo { uint64_t u64; struct cvmx_mio_ptp_clock_lo_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t frnanosec : 32; /**< Fractions of Nanoseconds */ #else uint64_t frnanosec : 32; uint64_t reserved_32_63 : 32; #endif } s; struct cvmx_mio_ptp_clock_lo_s cn63xx; struct cvmx_mio_ptp_clock_lo_s cn63xxp1; }; typedef union cvmx_mio_ptp_clock_lo cvmx_mio_ptp_clock_lo_t; /** * cvmx_mio_ptp_evt_cnt * * MIO_PTP_EVT_CNT = Event Counter * * Writes to MIO_PTP_EVT_CNT increment this register by the written data. The register counts down by * 1 for every MIO_PTP_CLOCK_CFG[EVCNT_EDGE] edge of MIO_PTP_CLOCK_CFG[EVCNT_IN]. When register equals * 0, an interrupt gets gerated */ union cvmx_mio_ptp_evt_cnt { uint64_t u64; struct cvmx_mio_ptp_evt_cnt_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t cntr : 64; /**< Nanoseconds */ #else uint64_t cntr : 64; #endif } s; struct cvmx_mio_ptp_evt_cnt_s cn63xx; struct cvmx_mio_ptp_evt_cnt_s cn63xxp1; }; typedef union cvmx_mio_ptp_evt_cnt cvmx_mio_ptp_evt_cnt_t; /** * cvmx_mio_ptp_timestamp * * MIO_PTP_TIMESTAMP = Timestamp latched on MIO_PTP_CLOCK_CFG[TSTMP_EDGE] edge of MIO_PTP_CLOCK_CFG[TSTMP_IN] * */ union cvmx_mio_ptp_timestamp { uint64_t u64; struct cvmx_mio_ptp_timestamp_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t nanosec : 64; /**< Nanoseconds */ #else uint64_t nanosec : 64; #endif } s; struct cvmx_mio_ptp_timestamp_s cn63xx; struct cvmx_mio_ptp_timestamp_s cn63xxp1; }; typedef union cvmx_mio_ptp_timestamp cvmx_mio_ptp_timestamp_t; /** * cvmx_mio_rst_boot */ union cvmx_mio_rst_boot { uint64_t u64; struct cvmx_mio_rst_boot_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_36_63 : 28; uint64_t c_mul : 6; /**< Core clock multiplier: C_MUL = (core clk speed) / (ref clock speed) "ref clock speed" should always be 50MHz. If PLL_QLM_REF_CLK_EN=0, "ref clock" comes from PLL_REF_CLK pin. If PLL_QLM_REF_CLK_EN=1, "ref clock" is 1/2 speed of QLMC_REF_CLK_* pins. */ uint64_t pnr_mul : 6; /**< Coprocessor clock multiplier: PNR_MUL = (coprocessor clk speed) / (ref clock speed) See C_MUL comments about ref clock. */ uint64_t qlm2_spd : 4; /**< QLM2_SPD pins sampled at DCOK assertion */ uint64_t qlm1_spd : 4; /**< QLM1_SPD pins sampled at DCOK assertion */ uint64_t qlm0_spd : 4; /**< QLM0_SPD pins sampled at DCOK assertion */ uint64_t lboot : 10; /**< Last boot cause mask, resets only with dock. bit9 - Soft reset due to watchdog bit8 - Soft reset due to CIU_SOFT_RST write bit7 - Warm reset due to cntl0 link-down or hot-reset bit6 - Warm reset due to cntl1 link-down or hot-reset bit5 - Cntl1 reset due to PERST1_L pin bit4 - Cntl0 reset due to PERST0_L pin bit3 - Warm reset due to PERST1_L pin bit2 - Warm reset due to PERST0_L pin bit1 - Warm reset due to CHIP_RESET_L pin bit0 - Cold reset due to DCOK pin */ uint64_t rboot : 1; /**< Determines whether core 0 remains in reset after after chip cold/warm/soft reset. */ uint64_t rboot_pin : 1; /**< Read-only access to REMOTE_BOOT pin */ #else uint64_t rboot_pin : 1; uint64_t rboot : 1; uint64_t lboot : 10; uint64_t qlm0_spd : 4; uint64_t qlm1_spd : 4; uint64_t qlm2_spd : 4; uint64_t pnr_mul : 6; uint64_t c_mul : 6; uint64_t reserved_36_63 : 28; #endif } s; struct cvmx_mio_rst_boot_s cn63xx; struct cvmx_mio_rst_boot_s cn63xxp1; }; typedef union cvmx_mio_rst_boot cvmx_mio_rst_boot_t; /** * cvmx_mio_rst_cfg * * Notes: * Cold reset will always performs a full bist. * */ union cvmx_mio_rst_cfg { uint64_t u64; struct cvmx_mio_rst_cfg_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t bist_delay : 58; /**< Reserved */ uint64_t reserved_3_5 : 3; uint64_t cntl_clr_bist : 1; /**< Peform clear bist during cntl only reset, instead of a full bist. A warm/soft reset will not change this field. */ uint64_t warm_clr_bist : 1; /**< Peform clear bist during warm reset, instead of a full bist. A warm/soft reset will not change this field. */ uint64_t soft_clr_bist : 1; /**< Peform clear bist during soft reset, instead of a full bist. A warm/soft reset will not change this field. */ #else uint64_t soft_clr_bist : 1; uint64_t warm_clr_bist : 1; uint64_t cntl_clr_bist : 1; uint64_t reserved_3_5 : 3; uint64_t bist_delay : 58; #endif } s; struct cvmx_mio_rst_cfg_s cn63xx; struct cvmx_mio_rst_cfg_cn63xxp1 { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t bist_delay : 58; /**< Reserved */ uint64_t reserved_2_5 : 4; uint64_t warm_clr_bist : 1; /**< Peform clear bist during warm reset, instead of a full bist. A warm/soft reset will not change this field. */ uint64_t soft_clr_bist : 1; /**< Peform clear bist during soft reset, instead of a full bist. A warm/soft reset will not change this field. */ #else uint64_t soft_clr_bist : 1; uint64_t warm_clr_bist : 1; uint64_t reserved_2_5 : 4; uint64_t bist_delay : 58; #endif } cn63xxp1; }; typedef union cvmx_mio_rst_cfg cvmx_mio_rst_cfg_t; /** * cvmx_mio_rst_ctl# */ union cvmx_mio_rst_ctlx { uint64_t u64; struct cvmx_mio_rst_ctlx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t prst_link : 1; /**< Controls whether corresponding controller link-down or hot-reset causes the assertion of CIU_SOFT_PRST*[SOFT_PRST] A warm/soft reset will not change this field. On cold reset, this field is initialized to 0 follows: 0 = when corresponding strap QLM*_HOST_MODE=1 1 = when corresponding strap QLM*_HOST_MODE=0 ***NOTE: Added in pass 2.0 */ uint64_t rst_done : 1; /**< Read-only access to controller reset status RESET_DONE is always zero (i.e. the controller is held in reset) when: - CIU_SOFT_PRST*[SOFT_PRST]=1, or - RST_RCV==1 and PERST*_L pin is asserted */ uint64_t rst_link : 1; /**< Controls whether corresponding controller link-down or hot-reset causes a warm chip reset On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=1 1 = when corresponding strap QLM*_HOST_MODE=0 Note that a link-down or hot-reset event can never cause a warm chip reset when the controller is in reset (i.e. can never cause a warm reset when RST_DONE==0). */ uint64_t host_mode : 1; /**< RO access to corresponding strap QLM*_HOST_MODE */ uint64_t prtmode : 2; /**< Port mode 0 = port is EP mode 1 = port is RC mode 2,3 = Reserved A warm/soft reset will not change this field. On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=0 1 = when corresponding strap QLM*_HOST_MODE=1 */ uint64_t rst_drv : 1; /**< Controls whether corresponding PERST*_L chip pin is driven by the OCTEON. A warm/soft reset will not change this field. On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=0 1 = when corresponding strap QLM*_HOST_MODE=1 When set, OCTEON drives the corresponding PERST*_L pin. Otherwise, OCTEON does not drive the corresponding PERST*_L pin. */ uint64_t rst_rcv : 1; /**< Controls whether corresponding PERST*_L chip pin is recieved by OCTEON. A warm/soft reset will not change this field. On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=1 1 = when corresponding strap QLM*_HOST_MODE=0 When RST_RCV==1, the PERST*_L value is received and may be used to reset the controller and (optionally, based on RST_CHIP) warm reset the chip. When RST_RCV==1 (and RST_CHIP=0), MIO_RST_INT[PERST*] gets set when the PERST*_L pin asserts. (This interrupt can alert SW whenever the external reset pin initiates a controller reset sequence.) RST_VAL gives the PERST*_L pin value when RST_RCV==1. When RST_RCV==0, the PERST*_L pin value is ignored. */ uint64_t rst_chip : 1; /**< Controls whether corresponding PERST*_L chip pin causes a chip warm reset like CHIP_RESET_L. A warm/soft reset will not change this field. On cold reset, this field is initialized to 0. RST_CHIP is not used when RST_RCV==0. When RST_RCV==0, RST_CHIP is ignored. When RST_RCV==1, RST_CHIP==1, and PERST*_L asserts, a chip warm reset will be generated. */ uint64_t rst_val : 1; /**< Read-only access to corresponding PERST*_L pin Unpredictable when RST_RCV==0. Reads as 1 when RST_RCV==1 and the PERST*_L pin is asserted. Reads as 0 when RST_RCV==1 and the PERST*_L pin is not asserted. */ #else uint64_t rst_val : 1; uint64_t rst_chip : 1; uint64_t rst_rcv : 1; uint64_t rst_drv : 1; uint64_t prtmode : 2; uint64_t host_mode : 1; uint64_t rst_link : 1; uint64_t rst_done : 1; uint64_t prst_link : 1; uint64_t reserved_10_63 : 54; #endif } s; struct cvmx_mio_rst_ctlx_s cn63xx; struct cvmx_mio_rst_ctlx_cn63xxp1 { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_9_63 : 55; uint64_t rst_done : 1; /**< Read-only access to controller reset status RESET_DONE is always zero (i.e. the controller is held in reset) when: - CIU_SOFT_PRST*[SOFT_PRST]=1, or - RST_RCV==1 and PERST*_L pin is asserted */ uint64_t rst_link : 1; /**< Controls whether corresponding controller link-down or hot-reset causes a warm chip reset On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=1 1 = when corresponding strap QLM*_HOST_MODE=0 Note that a link-down or hot-reset event can never cause a warm chip reset when the controller is in reset (i.e. can never cause a warm reset when RST_DONE==0). */ uint64_t host_mode : 1; /**< RO access to corresponding strap QLM*_HOST_MODE */ uint64_t prtmode : 2; /**< Port mode 0 = port is EP mode 1 = port is RC mode 2,3 = Reserved A warm/soft reset will not change this field. On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=0 1 = when corresponding strap QLM*_HOST_MODE=1 */ uint64_t rst_drv : 1; /**< Controls whether corresponding PERST*_L chip pin is driven by the OCTEON. A warm/soft reset will not change this field. On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=0 1 = when corresponding strap QLM*_HOST_MODE=1 When set, OCTEON drives the corresponding PERST*_L pin. Otherwise, OCTEON does not drive the corresponding PERST*_L pin. */ uint64_t rst_rcv : 1; /**< Controls whether corresponding PERST*_L chip pin is recieved by OCTEON. A warm/soft reset will not change this field. On cold reset, this field is initialized as follows: 0 = when corresponding strap QLM*_HOST_MODE=1 1 = when corresponding strap QLM*_HOST_MODE=0 When RST_RCV==1, the PERST*_L value is received and may be used to reset the controller and (optionally, based on RST_CHIP) warm reset the chip. When RST_RCV==1 (and RST_CHIP=0), MIO_RST_INT[PERST*] gets set when the PERST*_L pin asserts. (This interrupt can alert SW whenever the external reset pin initiates a controller reset sequence.) RST_VAL gives the PERST*_L pin value when RST_RCV==1. When RST_RCV==0, the PERST*_L pin value is ignored. */ uint64_t rst_chip : 1; /**< Controls whether corresponding PERST*_L chip pin causes a chip warm reset like CHIP_RESET_L. A warm/soft reset will not change this field. On cold reset, this field is initialized to 0. RST_CHIP is not used when RST_RCV==0. When RST_RCV==0, RST_CHIP is ignored. When RST_RCV==1, RST_CHIP==1, and PERST*_L asserts, a chip warm reset will be generated. */ uint64_t rst_val : 1; /**< Read-only access to corresponding PERST*_L pin Unpredictable when RST_RCV==0. Reads as 1 when RST_RCV==1 and the PERST*_L pin is asserted. Reads as 0 when RST_RCV==1 and the PERST*_L pin is not asserted. */ #else uint64_t rst_val : 1; uint64_t rst_chip : 1; uint64_t rst_rcv : 1; uint64_t rst_drv : 1; uint64_t prtmode : 2; uint64_t host_mode : 1; uint64_t rst_link : 1; uint64_t rst_done : 1; uint64_t reserved_9_63 : 55; #endif } cn63xxp1; }; typedef union cvmx_mio_rst_ctlx cvmx_mio_rst_ctlx_t; /** * cvmx_mio_rst_delay */ union cvmx_mio_rst_delay { uint64_t u64; struct cvmx_mio_rst_delay_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_32_63 : 32; uint64_t soft_rst_dly : 16; /**< A soft reset immediately causes an early soft reset notification. However, the assertion of soft reset will be delayed this many sclks. A warm/soft reset will not change this field. NOTE: This must be at least 500 dclks */ uint64_t warm_rst_dly : 16; /**< A warm reset immediately causes an early warm reset notification. However, the assertion of warm reset will be delayed this many sclks. A warm/soft reset will not change this field. NOTE: This must be at least 500 dclks */ #else uint64_t warm_rst_dly : 16; uint64_t soft_rst_dly : 16; uint64_t reserved_32_63 : 32; #endif } s; struct cvmx_mio_rst_delay_s cn63xx; struct cvmx_mio_rst_delay_s cn63xxp1; }; typedef union cvmx_mio_rst_delay cvmx_mio_rst_delay_t; /** * cvmx_mio_rst_int * * MIO_RST_INT = MIO Reset Interrupt Register * */ union cvmx_mio_rst_int { uint64_t u64; struct cvmx_mio_rst_int_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t perst1 : 1; /**< PERST1_L asserted while MIO_RST_CTL1[RST_RCV]=1 and MIO_RST_CTL1[RST_CHIP]=0 */ uint64_t perst0 : 1; /**< PERST0_L asserted while MIO_RST_CTL0[RST_RCV]=1 and MIO_RST_CTL0[RST_CHIP]=0 */ uint64_t reserved_2_7 : 6; uint64_t rst_link1 : 1; /**< A controller1 link-down/hot-reset occurred while MIO_RST_CTL1[RST_LINK]=0. Software must assert then de-assert CIU_SOFT_PRST1[SOFT_PRST] */ uint64_t rst_link0 : 1; /**< A controller0 link-down/hot-reset occurred while MIO_RST_CTL0[RST_LINK]=0. Software must assert then de-assert CIU_SOFT_PRST[SOFT_PRST] */ #else uint64_t rst_link0 : 1; uint64_t rst_link1 : 1; uint64_t reserved_2_7 : 6; uint64_t perst0 : 1; uint64_t perst1 : 1; uint64_t reserved_10_63 : 54; #endif } s; struct cvmx_mio_rst_int_s cn63xx; struct cvmx_mio_rst_int_s cn63xxp1; }; typedef union cvmx_mio_rst_int cvmx_mio_rst_int_t; /** * cvmx_mio_rst_int_en * * MIO_RST_INT_EN = MIO Reset Interrupt Enable Register * */ union cvmx_mio_rst_int_en { uint64_t u64; struct cvmx_mio_rst_int_en_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t perst1 : 1; /**< Controller1 PERST reset interrupt enable */ uint64_t perst0 : 1; /**< Controller0 PERST reset interrupt enable */ uint64_t reserved_2_7 : 6; uint64_t rst_link1 : 1; /**< Controller1 link-down/hot reset interrupt enable */ uint64_t rst_link0 : 1; /**< Controller0 link-down/hot reset interrupt enable */ #else uint64_t rst_link0 : 1; uint64_t rst_link1 : 1; uint64_t reserved_2_7 : 6; uint64_t perst0 : 1; uint64_t perst1 : 1; uint64_t reserved_10_63 : 54; #endif } s; struct cvmx_mio_rst_int_en_s cn63xx; struct cvmx_mio_rst_int_en_s cn63xxp1; }; typedef union cvmx_mio_rst_int_en cvmx_mio_rst_int_en_t; /** * cvmx_mio_tws#_int * * MIO_TWSX_INT = TWSX Interrupt Register * * This register contains the TWSI interrupt enable mask and the interrupt source bits. Note: the * interrupt source bit for the TWSI core interrupt (CORE_INT) is read-only, the appropriate sequence * must be written to the TWSI core to clear this interrupt. The other interrupt source bits are write- * one-to-clear. TS_INT is set on the update of the MIO_TWS_TWSI_SW register (i.e. when it is written * by a TWSI device). ST_INT is set whenever the valid bit of the MIO_TWS_SW_TWSI is cleared (see above * for reasons). * * Note: When using the high-level controller, CORE_EN should be clear and CORE_INT should be ignored. * Conversely, when the high-level controller is disabled, ST_EN / TS_EN should be clear and ST_INT / * TS_INT should be ignored. * * This register also contains a read-only copy of the TWSI bus (SCL and SDA) as well as control bits to * override the current state of the TWSI bus (SCL_OVR and SDA_OVR). Setting an override bit high will * result in the open drain driver being activated, thus driving the corresponding signal low. */ union cvmx_mio_twsx_int { uint64_t u64; struct cvmx_mio_twsx_int_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_12_63 : 52; uint64_t scl : 1; /**< SCL */ uint64_t sda : 1; /**< SDA */ uint64_t scl_ovr : 1; /**< SCL override */ uint64_t sda_ovr : 1; /**< SDA override */ uint64_t reserved_7_7 : 1; uint64_t core_en : 1; /**< TWSI core interrupt enable */ uint64_t ts_en : 1; /**< MIO_TWS_TWSI_SW register update interrupt enable */ uint64_t st_en : 1; /**< MIO_TWS_SW_TWSI register update interrupt enable */ uint64_t reserved_3_3 : 1; uint64_t core_int : 1; /**< TWSI core interrupt */ uint64_t ts_int : 1; /**< MIO_TWS_TWSI_SW register update interrupt */ uint64_t st_int : 1; /**< MIO_TWS_SW_TWSI register update interrupt */ #else uint64_t st_int : 1; uint64_t ts_int : 1; uint64_t core_int : 1; uint64_t reserved_3_3 : 1; uint64_t st_en : 1; uint64_t ts_en : 1; uint64_t core_en : 1; uint64_t reserved_7_7 : 1; uint64_t sda_ovr : 1; uint64_t scl_ovr : 1; uint64_t sda : 1; uint64_t scl : 1; uint64_t reserved_12_63 : 52; #endif } s; struct cvmx_mio_twsx_int_s cn30xx; struct cvmx_mio_twsx_int_s cn31xx; struct cvmx_mio_twsx_int_s cn38xx; struct cvmx_mio_twsx_int_cn38xxp2 { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_7_63 : 57; uint64_t core_en : 1; /**< TWSI core interrupt enable */ uint64_t ts_en : 1; /**< MIO_TWS_TWSI_SW register update interrupt enable */ uint64_t st_en : 1; /**< MIO_TWS_SW_TWSI register update interrupt enable */ uint64_t reserved_3_3 : 1; uint64_t core_int : 1; /**< TWSI core interrupt */ uint64_t ts_int : 1; /**< MIO_TWS_TWSI_SW register update interrupt */ uint64_t st_int : 1; /**< MIO_TWS_SW_TWSI register update interrupt */ #else uint64_t st_int : 1; uint64_t ts_int : 1; uint64_t core_int : 1; uint64_t reserved_3_3 : 1; uint64_t st_en : 1; uint64_t ts_en : 1; uint64_t core_en : 1; uint64_t reserved_7_63 : 57; #endif } cn38xxp2; struct cvmx_mio_twsx_int_s cn50xx; struct cvmx_mio_twsx_int_s cn52xx; struct cvmx_mio_twsx_int_s cn52xxp1; struct cvmx_mio_twsx_int_s cn56xx; struct cvmx_mio_twsx_int_s cn56xxp1; struct cvmx_mio_twsx_int_s cn58xx; struct cvmx_mio_twsx_int_s cn58xxp1; struct cvmx_mio_twsx_int_s cn63xx; struct cvmx_mio_twsx_int_s cn63xxp1; }; typedef union cvmx_mio_twsx_int cvmx_mio_twsx_int_t; /** * cvmx_mio_tws#_sw_twsi * * MIO_TWSX_SW_TWSI = TWSX Software to TWSI Register * * This register allows software to * - initiate TWSI interface master-mode operations with a write and read the result with a read * - load four bytes for later retrieval (slave mode) with a write and check validity with a read * - launch a TWSI controller configuration read/write with a write and read the result with a read * * This register should be read or written by software, and read by the TWSI device. The TWSI device can * use either two-byte or five-byte reads to reference this register. * * The TWSI device considers this register valid when V==1 and SLONLY==1. */ union cvmx_mio_twsx_sw_twsi { uint64_t u64; struct cvmx_mio_twsx_sw_twsi_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t v : 1; /**< Valid bit - Set on a write (should always be written with a 1) - Cleared when a TWSI master mode op completes - Cleared when a TWSI configuration register access completes - Cleared when the TWSI device reads the register if SLONLY==1 */ uint64_t slonly : 1; /**< Slave Only Mode - No operation is initiated with a write when this bit is set - only D field is updated in this case - When clear, a write initiates either a TWSI master-mode operation or a TWSI configuration register access */ uint64_t eia : 1; /**< Extended Internal Address - send additional internal address byte (MSB of IA is from IA field of MIO_TWS_SW_TWSI_EXT) */ uint64_t op : 4; /**< Opcode field - When the register is written with SLONLY==0, initiate a read or write: 0000 => 7-bit Byte Master Mode TWSI Op 0001 => 7-bit Byte Combined Read Master Mode Op 7-bit Byte Write w/ IA Master Mode Op 0010 => 10-bit Byte Master Mode TWSI Op 0011 => 10-bit Byte Combined Read Master Mode Op 10-bit Byte Write w/ IA Master Mode Op 0100 => TWSI Master Clock Register 0110 => See EOP field 1000 => 7-bit 4-byte Master Mode TWSI Op 1001 => 7-bit 4-byte Comb. Read Master Mode Op 7-bit 4-byte Write w/ IA Master Mode Op 1010 => 10-bit 4-byte Master Mode TWSI Op 1011 => 10-bit 4-byte Comb. Read Master Mode Op 10-bit 4-byte Write w/ IA Master Mode Op */ uint64_t r : 1; /**< Read bit or result - If set on a write when SLONLY==0, the operation is a read - On a read, this bit returns the result indication for the most recent master mode operation (1 = success, 0 = fail) */ uint64_t sovr : 1; /**< Size Override - if set, use the SIZE field to determine Master Mode Op size rather than what the Opcode field specifies. For operations greater than 4 bytes, the additional data will be contained in the D field of MIO_TWS_SW_TWSI_EXT */ uint64_t size : 3; /**< Size in bytes of Master Mode Op if the Size Override bit is set. Specified in -1 notation (i.e. 0 = 1 byte, 1 = 2 bytes ... 7 = 8 bytes) */ uint64_t scr : 2; /**< Scratch - unused, but retain state */ uint64_t a : 10; /**< Address field - the address of the remote device for a master mode operation - A<9:7> are only used for 10-bit addressing Note that when mastering a 7-bit OP, A<6:0> should not take any of the values 0x78, 0x79, 0x7A nor 0x7B (these 7-bit addresses are reserved to extend to 10-bit addressing). */ uint64_t ia : 5; /**< Internal Address - Used when launching a master mode combined read / write with internal address (lower 3 bits are contained in the EOP_IA field) */ uint64_t eop_ia : 3; /**< Extra opcode (when OP<3:0> == 0110 and SLONLY==0): 000 => TWSI Slave Address Register 001 => TWSI Data Register 010 => TWSI Control Register 011 => TWSI Clock Control Register (when R == 0) 011 => TWSI Status Register (when R == 1) 100 => TWSI Extended Slave Register 111 => TWSI Soft Reset Register Also the lower 3 bits of Internal Address when launching a master mode combined read / write with internal address */ uint64_t d : 32; /**< Data Field Used on a write when - initiating a master-mode write (SLONLY==0) - writing a TWSI config register (SLONLY==0) - a slave mode write (SLONLY==1) The read value is updated by - a write to this register - master mode completion (contains result or error code) - TWSI config register read (contains result) */ #else uint64_t d : 32; uint64_t eop_ia : 3; uint64_t ia : 5; uint64_t a : 10; uint64_t scr : 2; uint64_t size : 3; uint64_t sovr : 1; uint64_t r : 1; uint64_t op : 4; uint64_t eia : 1; uint64_t slonly : 1; uint64_t v : 1; #endif } s; struct cvmx_mio_twsx_sw_twsi_s cn30xx; struct cvmx_mio_twsx_sw_twsi_s cn31xx; struct cvmx_mio_twsx_sw_twsi_s cn38xx; struct cvmx_mio_twsx_sw_twsi_s cn38xxp2; struct cvmx_mio_twsx_sw_twsi_s cn50xx; struct cvmx_mio_twsx_sw_twsi_s cn52xx; struct cvmx_mio_twsx_sw_twsi_s cn52xxp1; struct cvmx_mio_twsx_sw_twsi_s cn56xx; struct cvmx_mio_twsx_sw_twsi_s cn56xxp1; struct cvmx_mio_twsx_sw_twsi_s cn58xx; struct cvmx_mio_twsx_sw_twsi_s cn58xxp1; struct cvmx_mio_twsx_sw_twsi_s cn63xx; struct cvmx_mio_twsx_sw_twsi_s cn63xxp1; }; typedef union cvmx_mio_twsx_sw_twsi cvmx_mio_twsx_sw_twsi_t; /** * cvmx_mio_tws#_sw_twsi_ext * * MIO_TWSX_SW_TWSI_EXT = TWSX Software to TWSI Extension Register * * This register contains an additional byte of internal address and 4 additional bytes of data to be * used with TWSI master mode operations. IA will be sent as the first byte of internal address when * performing master mode combined read / write with internal address operations and the EIA bit of * MIO_TWS_SW_TWSI is set. D extends the data field of MIO_TWS_SW_TWSI for a total of 8 bytes (SOVR * must be set to perform operations greater than 4 bytes). */ union cvmx_mio_twsx_sw_twsi_ext { uint64_t u64; struct cvmx_mio_twsx_sw_twsi_ext_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_40_63 : 24; uint64_t ia : 8; /**< Extended Internal Address */ uint64_t d : 32; /**< Extended Data Field */ #else uint64_t d : 32; uint64_t ia : 8; uint64_t reserved_40_63 : 24; #endif } s; struct cvmx_mio_twsx_sw_twsi_ext_s cn30xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn31xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn38xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn38xxp2; struct cvmx_mio_twsx_sw_twsi_ext_s cn50xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn52xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn52xxp1; struct cvmx_mio_twsx_sw_twsi_ext_s cn56xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn56xxp1; struct cvmx_mio_twsx_sw_twsi_ext_s cn58xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn58xxp1; struct cvmx_mio_twsx_sw_twsi_ext_s cn63xx; struct cvmx_mio_twsx_sw_twsi_ext_s cn63xxp1; }; typedef union cvmx_mio_twsx_sw_twsi_ext cvmx_mio_twsx_sw_twsi_ext_t; /** * cvmx_mio_tws#_twsi_sw * * MIO_TWSX_TWSI_SW = TWSX TWSI to Software Register * * This register allows the TWSI device to transfer data to software and later check that software has * received the information. * * This register should be read or written by the TWSI device, and read by software. The TWSI device can * use one-byte or four-byte payload writes, and two-byte payload reads. * * The TWSI device considers this register valid when V==1. */ union cvmx_mio_twsx_twsi_sw { uint64_t u64; struct cvmx_mio_twsx_twsi_sw_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t v : 2; /**< Valid Bits - Not directly writable - Set to 1 on any write by the TWSI device - Cleared on any read by software */ uint64_t reserved_32_61 : 30; uint64_t d : 32; /**< Data Field - updated on a write by the TWSI device */ #else uint64_t d : 32; uint64_t reserved_32_61 : 30; uint64_t v : 2; #endif } s; struct cvmx_mio_twsx_twsi_sw_s cn30xx; struct cvmx_mio_twsx_twsi_sw_s cn31xx; struct cvmx_mio_twsx_twsi_sw_s cn38xx; struct cvmx_mio_twsx_twsi_sw_s cn38xxp2; struct cvmx_mio_twsx_twsi_sw_s cn50xx; struct cvmx_mio_twsx_twsi_sw_s cn52xx; struct cvmx_mio_twsx_twsi_sw_s cn52xxp1; struct cvmx_mio_twsx_twsi_sw_s cn56xx; struct cvmx_mio_twsx_twsi_sw_s cn56xxp1; struct cvmx_mio_twsx_twsi_sw_s cn58xx; struct cvmx_mio_twsx_twsi_sw_s cn58xxp1; struct cvmx_mio_twsx_twsi_sw_s cn63xx; struct cvmx_mio_twsx_twsi_sw_s cn63xxp1; }; typedef union cvmx_mio_twsx_twsi_sw cvmx_mio_twsx_twsi_sw_t; /** * cvmx_mio_uart#_dlh * * MIO_UARTX_DLH = MIO UARTX Divisor Latch High Register * * The DLH (Divisor Latch High) register in conjunction with DLL (Divisor Latch Low) register form a * 16-bit, read/write, Divisor Latch register that contains the baud rate divisor for the UART. It is * accessed by first setting the DLAB bit (bit 7) in the Line Control Register (LCR). The output baud * rate is equal to eclk frequency divided by sixteen times the value of the baud rate divisor, as * follows: baud rate = eclk / (16 * divisor). * * Note that the BUSY bit (bit 0) of the UART Status Register (USR) must be clear before writing this * register. BUSY bit is always clear in PASS3. * * Note that with the Divisor Latch Registers (DLL and DLH) set to zero, the baud clock is disabled * and no serial communications will occur. Also, once the DLL or DLH is set, at least 8 clock cycles * of eclk should be allowed to pass before transmitting or receiving data. * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * IER and DLH registers are the same. */ union cvmx_mio_uartx_dlh { uint64_t u64; struct cvmx_mio_uartx_dlh_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dlh : 8; /**< Divisor Latch High Register */ #else uint64_t dlh : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_dlh_s cn30xx; struct cvmx_mio_uartx_dlh_s cn31xx; struct cvmx_mio_uartx_dlh_s cn38xx; struct cvmx_mio_uartx_dlh_s cn38xxp2; struct cvmx_mio_uartx_dlh_s cn50xx; struct cvmx_mio_uartx_dlh_s cn52xx; struct cvmx_mio_uartx_dlh_s cn52xxp1; struct cvmx_mio_uartx_dlh_s cn56xx; struct cvmx_mio_uartx_dlh_s cn56xxp1; struct cvmx_mio_uartx_dlh_s cn58xx; struct cvmx_mio_uartx_dlh_s cn58xxp1; struct cvmx_mio_uartx_dlh_s cn63xx; struct cvmx_mio_uartx_dlh_s cn63xxp1; }; typedef union cvmx_mio_uartx_dlh cvmx_mio_uartx_dlh_t; typedef cvmx_mio_uartx_dlh_t cvmx_uart_dlh_t; /** * cvmx_mio_uart#_dll * * MIO_UARTX_DLL = MIO UARTX Divisor Latch Low Register * * The DLH (Divisor Latch High) register in conjunction with DLL (Divisor Latch Low) register form a * 16-bit, read/write, Divisor Latch register that contains the baud rate divisor for the UART. It is * accessed by first setting the DLAB bit (bit 7) in the Line Control Register (LCR). The output baud * rate is equal to eclk frequency divided by sixteen times the value of the baud rate divisor, as * follows: baud rate = eclk / (16 * divisor). * * Note that the BUSY bit (bit 0) of the UART Status Register (USR) must be clear before writing this * register. BUSY bit is always clear in PASS3. * * Note that with the Divisor Latch Registers (DLL and DLH) set to zero, the baud clock is disabled * and no serial communications will occur. Also, once the DLL or DLH is set, at least 8 clock cycles * of eclk should be allowed to pass before transmitting or receiving data. * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * RBR, THR, and DLL registers are the same. */ union cvmx_mio_uartx_dll { uint64_t u64; struct cvmx_mio_uartx_dll_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dll : 8; /**< Divisor Latch Low Register */ #else uint64_t dll : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_dll_s cn30xx; struct cvmx_mio_uartx_dll_s cn31xx; struct cvmx_mio_uartx_dll_s cn38xx; struct cvmx_mio_uartx_dll_s cn38xxp2; struct cvmx_mio_uartx_dll_s cn50xx; struct cvmx_mio_uartx_dll_s cn52xx; struct cvmx_mio_uartx_dll_s cn52xxp1; struct cvmx_mio_uartx_dll_s cn56xx; struct cvmx_mio_uartx_dll_s cn56xxp1; struct cvmx_mio_uartx_dll_s cn58xx; struct cvmx_mio_uartx_dll_s cn58xxp1; struct cvmx_mio_uartx_dll_s cn63xx; struct cvmx_mio_uartx_dll_s cn63xxp1; }; typedef union cvmx_mio_uartx_dll cvmx_mio_uartx_dll_t; typedef cvmx_mio_uartx_dll_t cvmx_uart_dll_t; /** * cvmx_mio_uart#_far * * MIO_UARTX_FAR = MIO UARTX FIFO Access Register * * The FIFO Access Register (FAR) is used to enable a FIFO access mode for testing, so that the receive * FIFO can be written by software and the transmit FIFO can be read by software when the FIFOs are * enabled. When FIFOs are not enabled it allows the RBR to be written by software and the THR to be read * by software. Note, that when the FIFO access mode is enabled/disabled, the control portion of the * receive FIFO and transmit FIFO is reset and the FIFOs are treated as empty. */ union cvmx_mio_uartx_far { uint64_t u64; struct cvmx_mio_uartx_far_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t far : 1; /**< FIFO Access Register */ #else uint64_t far : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uartx_far_s cn30xx; struct cvmx_mio_uartx_far_s cn31xx; struct cvmx_mio_uartx_far_s cn38xx; struct cvmx_mio_uartx_far_s cn38xxp2; struct cvmx_mio_uartx_far_s cn50xx; struct cvmx_mio_uartx_far_s cn52xx; struct cvmx_mio_uartx_far_s cn52xxp1; struct cvmx_mio_uartx_far_s cn56xx; struct cvmx_mio_uartx_far_s cn56xxp1; struct cvmx_mio_uartx_far_s cn58xx; struct cvmx_mio_uartx_far_s cn58xxp1; struct cvmx_mio_uartx_far_s cn63xx; struct cvmx_mio_uartx_far_s cn63xxp1; }; typedef union cvmx_mio_uartx_far cvmx_mio_uartx_far_t; typedef cvmx_mio_uartx_far_t cvmx_uart_far_t; /** * cvmx_mio_uart#_fcr * * MIO_UARTX_FCR = MIO UARTX FIFO Control Register * * The FIFO Control Register (FCR) is a write-only register that controls the read and write data FIFO * operation. When FIFOs and Programmable THRE Interrupt mode are enabled, this register also controls * the THRE Interrupt empty threshold level. * * Setting bit 0 of the FCR enables the transmit and receive FIFOs. Whenever the value of this bit is * changed both the TX and RX FIFOs will be reset. * * Writing a '1' to bit 1 of the FCR resets and flushes data in the receive FIFO. Note that this bit is * self-clearing and it is not necessary to clear this bit. * * Writing a '1' to bit 2 of the FCR resets and flushes data in the transmit FIFO. Note that this bit is * self-clearing and it is not necessary to clear this bit. * * If the FIFOs and Programmable THRE Interrupt mode are enabled, bits 4 and 5 control the empty * threshold level at which THRE Interrupts are generated when the mode is active. See the following * table for encodings: * * TX Trigger * ---------- * 00 = empty FIFO * 01 = 2 chars in FIFO * 10 = FIFO 1/4 full * 11 = FIFO 1/2 full * * If the FIFO mode is enabled (bit 0 of the FCR is set to '1') bits 6 and 7 are active. Bit 6 and bit 7 * set the trigger level in the receiver FIFO for the Enable Received Data Available Interrupt (ERBFI). * In auto flow control mode the trigger is used to determine when the rts_n signal will be deasserted. * See the following table for encodings: * * RX Trigger * ---------- * 00 = 1 char in FIFO * 01 = FIFO 1/4 full * 10 = FIFO 1/2 full * 11 = FIFO 2 chars less than full * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * IIR and FCR registers are the same. */ union cvmx_mio_uartx_fcr { uint64_t u64; struct cvmx_mio_uartx_fcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t rxtrig : 2; /**< RX Trigger */ uint64_t txtrig : 2; /**< TX Trigger */ uint64_t reserved_3_3 : 1; uint64_t txfr : 1; /**< TX FIFO reset */ uint64_t rxfr : 1; /**< RX FIFO reset */ uint64_t en : 1; /**< FIFO enable */ #else uint64_t en : 1; uint64_t rxfr : 1; uint64_t txfr : 1; uint64_t reserved_3_3 : 1; uint64_t txtrig : 2; uint64_t rxtrig : 2; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_fcr_s cn30xx; struct cvmx_mio_uartx_fcr_s cn31xx; struct cvmx_mio_uartx_fcr_s cn38xx; struct cvmx_mio_uartx_fcr_s cn38xxp2; struct cvmx_mio_uartx_fcr_s cn50xx; struct cvmx_mio_uartx_fcr_s cn52xx; struct cvmx_mio_uartx_fcr_s cn52xxp1; struct cvmx_mio_uartx_fcr_s cn56xx; struct cvmx_mio_uartx_fcr_s cn56xxp1; struct cvmx_mio_uartx_fcr_s cn58xx; struct cvmx_mio_uartx_fcr_s cn58xxp1; struct cvmx_mio_uartx_fcr_s cn63xx; struct cvmx_mio_uartx_fcr_s cn63xxp1; }; typedef union cvmx_mio_uartx_fcr cvmx_mio_uartx_fcr_t; typedef cvmx_mio_uartx_fcr_t cvmx_uart_fcr_t; /** * cvmx_mio_uart#_htx * * MIO_UARTX_HTX = MIO UARTX Halt TX Register * * The Halt TX Register (HTX) is used to halt transmissions for testing, so that the transmit FIFO can be * filled by software when FIFOs are enabled. If FIFOs are not enabled, setting the HTX register will * have no effect. */ union cvmx_mio_uartx_htx { uint64_t u64; struct cvmx_mio_uartx_htx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t htx : 1; /**< Halt TX */ #else uint64_t htx : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uartx_htx_s cn30xx; struct cvmx_mio_uartx_htx_s cn31xx; struct cvmx_mio_uartx_htx_s cn38xx; struct cvmx_mio_uartx_htx_s cn38xxp2; struct cvmx_mio_uartx_htx_s cn50xx; struct cvmx_mio_uartx_htx_s cn52xx; struct cvmx_mio_uartx_htx_s cn52xxp1; struct cvmx_mio_uartx_htx_s cn56xx; struct cvmx_mio_uartx_htx_s cn56xxp1; struct cvmx_mio_uartx_htx_s cn58xx; struct cvmx_mio_uartx_htx_s cn58xxp1; struct cvmx_mio_uartx_htx_s cn63xx; struct cvmx_mio_uartx_htx_s cn63xxp1; }; typedef union cvmx_mio_uartx_htx cvmx_mio_uartx_htx_t; typedef cvmx_mio_uartx_htx_t cvmx_uart_htx_t; /** * cvmx_mio_uart#_ier * * MIO_UARTX_IER = MIO UARTX Interrupt Enable Register * * Interrupt Enable Register (IER) is a read/write register that contains four bits that enable * the generation of interrupts. These four bits are the Enable Received Data Available Interrupt * (ERBFI), the Enable Transmitter Holding Register Empty Interrupt (ETBEI), the Enable Receiver Line * Status Interrupt (ELSI), and the Enable Modem Status Interrupt (EDSSI). * * The IER also contains an enable bit (PTIME) for the Programmable THRE Interrupt mode. * * Note: The Divisor Latch Address Bit (DLAB) of the Line Control Register (LCR) must be clear to access * this register. * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * IER and DLH registers are the same. */ union cvmx_mio_uartx_ier { uint64_t u64; struct cvmx_mio_uartx_ier_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t ptime : 1; /**< Programmable THRE Interrupt mode enable */ uint64_t reserved_4_6 : 3; uint64_t edssi : 1; /**< Enable Modem Status Interrupt */ uint64_t elsi : 1; /**< Enable Receiver Line Status Interrupt */ uint64_t etbei : 1; /**< Enable Transmitter Holding Register Empty Interrupt */ uint64_t erbfi : 1; /**< Enable Received Data Available Interrupt */ #else uint64_t erbfi : 1; uint64_t etbei : 1; uint64_t elsi : 1; uint64_t edssi : 1; uint64_t reserved_4_6 : 3; uint64_t ptime : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_ier_s cn30xx; struct cvmx_mio_uartx_ier_s cn31xx; struct cvmx_mio_uartx_ier_s cn38xx; struct cvmx_mio_uartx_ier_s cn38xxp2; struct cvmx_mio_uartx_ier_s cn50xx; struct cvmx_mio_uartx_ier_s cn52xx; struct cvmx_mio_uartx_ier_s cn52xxp1; struct cvmx_mio_uartx_ier_s cn56xx; struct cvmx_mio_uartx_ier_s cn56xxp1; struct cvmx_mio_uartx_ier_s cn58xx; struct cvmx_mio_uartx_ier_s cn58xxp1; struct cvmx_mio_uartx_ier_s cn63xx; struct cvmx_mio_uartx_ier_s cn63xxp1; }; typedef union cvmx_mio_uartx_ier cvmx_mio_uartx_ier_t; typedef cvmx_mio_uartx_ier_t cvmx_uart_ier_t; /** * cvmx_mio_uart#_iir * * MIO_UARTX_IIR = MIO UARTX Interrupt Identity Register * * The Interrupt Identity Register (IIR) is a read-only register that identifies the source of an * interrupt. The upper two bits of the register are FIFO-enabled bits. These bits are '00' if the FIFOs * are disabled, and '11' if they are enabled. The lower four bits identify the highest priority pending * interrupt. The following table defines interrupt source decoding, interrupt priority, and interrupt * reset control: * * Interrupt Priority Interrupt Interrupt Interrupt * ID Level Type Source Reset By * --------------------------------------------------------------------------------------------------------------------------------- * 0001 - None None - * * 0110 Highest Receiver Line Overrun, parity, or framing errors or break Reading the Line Status Register * Status interrupt * * 0100 Second Received Data Receiver data available (FIFOs disabled) or Reading the Receiver Buffer Register * Available RX FIFO trigger level reached (FIFOs (FIFOs disabled) or the FIFO drops below * enabled) the trigger level (FIFOs enabled) * * 1100 Second Character No characters in or out of the RX FIFO Reading the Receiver Buffer Register * Timeout during the last 4 character times and there * Indication is at least 1 character in it during this * time * * 0010 Third Transmitter Transmitter Holding Register Empty Reading the Interrupt Identity Register * Holding (Programmable THRE Mode disabled) or TX (if source of interrupt) or writing into * Register FIFO at or below threshold (Programmable THR (FIFOs or THRE Mode disabled) or TX * Empty THRE Mode enabled) FIFO above threshold (FIFOs and THRE * Mode enabled) * * 0000 Fourth Modem Status Clear To Send (CTS) or Data Set Ready (DSR) Reading the Modem Status Register * Changed or Ring Indicator (RI) or Data Carrier * Detect (DCD) changed (note: if auto flow * control mode is enabled, a change in CTS * will not cause an interrupt) * * 0111 Fifth Busy Detect Software has tried to write to the Line Reading the UART Status Register * Indication Control Register while the BUSY bit of the * UART Status Register was set * * Note: The Busy Detect Indication interrupt has been removed from PASS3 and will never assert. * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * IIR and FCR registers are the same. */ union cvmx_mio_uartx_iir { uint64_t u64; struct cvmx_mio_uartx_iir_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t fen : 2; /**< FIFO-enabled bits */ uint64_t reserved_4_5 : 2; cvmx_uart_iid_t iid : 4; /**< Interrupt ID */ #else cvmx_uart_iid_t iid : 4; uint64_t reserved_4_5 : 2; uint64_t fen : 2; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_iir_s cn30xx; struct cvmx_mio_uartx_iir_s cn31xx; struct cvmx_mio_uartx_iir_s cn38xx; struct cvmx_mio_uartx_iir_s cn38xxp2; struct cvmx_mio_uartx_iir_s cn50xx; struct cvmx_mio_uartx_iir_s cn52xx; struct cvmx_mio_uartx_iir_s cn52xxp1; struct cvmx_mio_uartx_iir_s cn56xx; struct cvmx_mio_uartx_iir_s cn56xxp1; struct cvmx_mio_uartx_iir_s cn58xx; struct cvmx_mio_uartx_iir_s cn58xxp1; struct cvmx_mio_uartx_iir_s cn63xx; struct cvmx_mio_uartx_iir_s cn63xxp1; }; typedef union cvmx_mio_uartx_iir cvmx_mio_uartx_iir_t; typedef cvmx_mio_uartx_iir_t cvmx_uart_iir_t; /** * cvmx_mio_uart#_lcr * * MIO_UARTX_LCR = MIO UARTX Line Control Register * * The Line Control Register (LCR) controls the format of the data that is transmitted and received by * the UART. * * LCR bits 0 and 1 are the Character Length Select field. This field is used to select the number of * data bits per character that are transmitted and received. See the following table for encodings: * * CLS * --- * 00 = 5 bits (bits 0-4 sent) * 01 = 6 bits (bits 0-5 sent) * 10 = 7 bits (bits 0-6 sent) * 11 = 8 bits (all bits sent) * * LCR bit 2 controls the number of stop bits transmitted. If bit 2 is a '0', one stop bit is transmitted * in the serial data. If bit 2 is a '1' and the data bits are set to '00', one and a half stop bits are * generated. Otherwise, two stop bits are generated and transmitted in the serial data out. Note that * regardless of the number of stop bits selected the receiver will only check the first stop bit. * * LCR bit 3 is the Parity Enable bit. This bit is used to enable and disable parity generation and * detection in transmitted and received serial character respectively. * * LCR bit 4 is the Even Parity Select bit. If parity is enabled, bit 4 selects between even and odd * parity. If bit 4 is a '1', an even number of ones is transmitted or checked. If bit 4 is a '0', an odd * number of ones is transmitted or checked. * * LCR bit 6 is the Break Control bit. Setting the Break bit sends a break signal by holding the sout * line low (when not in Loopback mode, as determined by Modem Control Register bit 4). When in Loopback * mode, the break condition is internally looped back to the receiver. * * LCR bit 7 is the Divisor Latch Address bit. Setting this bit enables reading and writing of the * Divisor Latch register (DLL and DLH) to set the baud rate of the UART. This bit must be cleared after * initial baud rate setup in order to access other registers. * * Note: The LCR is writeable only when the UART is not busy (when the BUSY bit (bit 0) of the UART * Status Register (USR) is clear). The LCR is always readable. In PASS3, the LCR is always writable * because the BUSY bit is always clear. */ union cvmx_mio_uartx_lcr { uint64_t u64; struct cvmx_mio_uartx_lcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dlab : 1; /**< Divisor Latch Address bit */ uint64_t brk : 1; /**< Break Control bit */ uint64_t reserved_5_5 : 1; uint64_t eps : 1; /**< Even Parity Select bit */ uint64_t pen : 1; /**< Parity Enable bit */ uint64_t stop : 1; /**< Stop Control bit */ cvmx_uart_bits_t cls : 2; /**< Character Length Select */ #else cvmx_uart_bits_t cls : 2; uint64_t stop : 1; uint64_t pen : 1; uint64_t eps : 1; uint64_t reserved_5_5 : 1; uint64_t brk : 1; uint64_t dlab : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_lcr_s cn30xx; struct cvmx_mio_uartx_lcr_s cn31xx; struct cvmx_mio_uartx_lcr_s cn38xx; struct cvmx_mio_uartx_lcr_s cn38xxp2; struct cvmx_mio_uartx_lcr_s cn50xx; struct cvmx_mio_uartx_lcr_s cn52xx; struct cvmx_mio_uartx_lcr_s cn52xxp1; struct cvmx_mio_uartx_lcr_s cn56xx; struct cvmx_mio_uartx_lcr_s cn56xxp1; struct cvmx_mio_uartx_lcr_s cn58xx; struct cvmx_mio_uartx_lcr_s cn58xxp1; struct cvmx_mio_uartx_lcr_s cn63xx; struct cvmx_mio_uartx_lcr_s cn63xxp1; }; typedef union cvmx_mio_uartx_lcr cvmx_mio_uartx_lcr_t; typedef cvmx_mio_uartx_lcr_t cvmx_uart_lcr_t; /** * cvmx_mio_uart#_lsr * * MIO_UARTX_LSR = MIO UARTX Line Status Register * * The Line Status Register (LSR) contains status of the receiver and transmitter data transfers. This * status can be read by the user at anytime. * * LSR bit 0 is the Data Ready (DR) bit. When set, this bit indicates the receiver contains at least one * character in the RBR or the receiver FIFO. This bit is cleared when the RBR is read in the non-FIFO * mode, or when the receiver FIFO is empty, in FIFO mode. * * LSR bit 1 is the Overrun Error (OE) bit. When set, this bit indicates an overrun error has occurred * because a new data character was received before the previous data was read. In the non-FIFO mode, the * OE bit is set when a new character arrives in the receiver before the previous character was read from * the RBR. When this happens, the data in the RBR is overwritten. In the FIFO mode, an overrun error * occurs when the FIFO is full and a new character arrives at the receiver. The data in the FIFO is * retained and the data in the receive shift register is lost. * * LSR bit 2 is the Parity Error (PE) bit. This bit is set whenever there is a parity error in the * receiver if the Parity Enable (PEN) bit in the LCR is set. In the FIFO mode, since the parity error is * associated with a character received, it is revealed when the character with the parity error arrives * at the top of the FIFO. It should be noted that the Parity Error (PE) bit will be set if a break * interrupt has occurred, as indicated by the Break Interrupt (BI) bit. * * LSR bit 3 is the Framing Error (FE) bit. This bit is set whenever there is a framing error in the * receiver. A framing error occurs when the receiver does not detect a valid STOP bit in the received * data. In the FIFO mode, since the framing error is associated with a character received, it is * revealed when the character with the framing error is at the top of the FIFO. When a framing error * occurs the UART will try resynchronize. It does this by assuming that the error was due to the start * bit of the next character and then continues receiving the other bits (i.e. data and/or parity and * stop). It should be noted that the Framing Error (FE) bit will be set if a break interrupt has * occurred, as indicated by the Break Interrupt (BI) bit. * * Note: The OE, PE, and FE bits are reset when a read of the LSR is performed. * * LSR bit 4 is the Break Interrupt (BI) bit. This bit is set whenever the serial input (sin) is held in * a 0 state for longer than the sum of start time + data bits + parity + stop bits. A break condition on * sin causes one and only one character, consisting of all zeros, to be received by the UART. In the * FIFO mode, the character associated with the break condition is carried through the FIFO and is * revealed when the character is at the top of the FIFO. Reading the LSR clears the BI bit. In the non- * FIFO mode, the BI indication occurs immediately and persists until the LSR is read. * * LSR bit 5 is the Transmitter Holding Register Empty (THRE) bit. When Programmable THRE Interrupt mode * is disabled, this bit indicates that the UART can accept a new character for transmission. This bit is * set whenever data is transferred from the THR (or TX FIFO) to the transmitter shift register and no * new data has been written to the THR (or TX FIFO). This also causes a THRE Interrupt to occur, if the * THRE Interrupt is enabled. When FIFOs and Programmable THRE Interrupt mode are enabled, LSR bit 5 * functionality is switched to indicate the transmitter FIFO is full, and no longer controls THRE * Interrupts, which are then controlled by the FCR[5:4] threshold setting. * * LSR bit 6 is the Transmitter Empty (TEMT) bit. In the FIFO mode, this bit is set whenever the * Transmitter Shift Register and the FIFO are both empty. In the non-FIFO mode, this bit is set whenever * the Transmitter Holding Register and the Transmitter Shift Register are both empty. This bit is * typically used to make sure it is safe to change control registers. Changing control registers while * the transmitter is busy can result in corrupt data being transmitted. * * LSR bit 7 is the Error in Receiver FIFO (FERR) bit. This bit is active only when FIFOs are enabled. It * is set when there is at least one parity error, framing error, or break indication in the FIFO. This * bit is cleared when the LSR is read and the character with the error is at the top of the receiver * FIFO and there are no subsequent errors in the FIFO. */ union cvmx_mio_uartx_lsr { uint64_t u64; struct cvmx_mio_uartx_lsr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t ferr : 1; /**< Error in Receiver FIFO bit */ uint64_t temt : 1; /**< Transmitter Empty bit */ uint64_t thre : 1; /**< Transmitter Holding Register Empty bit */ uint64_t bi : 1; /**< Break Interrupt bit */ uint64_t fe : 1; /**< Framing Error bit */ uint64_t pe : 1; /**< Parity Error bit */ uint64_t oe : 1; /**< Overrun Error bit */ uint64_t dr : 1; /**< Data Ready bit */ #else uint64_t dr : 1; uint64_t oe : 1; uint64_t pe : 1; uint64_t fe : 1; uint64_t bi : 1; uint64_t thre : 1; uint64_t temt : 1; uint64_t ferr : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_lsr_s cn30xx; struct cvmx_mio_uartx_lsr_s cn31xx; struct cvmx_mio_uartx_lsr_s cn38xx; struct cvmx_mio_uartx_lsr_s cn38xxp2; struct cvmx_mio_uartx_lsr_s cn50xx; struct cvmx_mio_uartx_lsr_s cn52xx; struct cvmx_mio_uartx_lsr_s cn52xxp1; struct cvmx_mio_uartx_lsr_s cn56xx; struct cvmx_mio_uartx_lsr_s cn56xxp1; struct cvmx_mio_uartx_lsr_s cn58xx; struct cvmx_mio_uartx_lsr_s cn58xxp1; struct cvmx_mio_uartx_lsr_s cn63xx; struct cvmx_mio_uartx_lsr_s cn63xxp1; }; typedef union cvmx_mio_uartx_lsr cvmx_mio_uartx_lsr_t; typedef cvmx_mio_uartx_lsr_t cvmx_uart_lsr_t; /** * cvmx_mio_uart#_mcr * * MIO_UARTX_MCR = MIO UARTX Modem Control Register * * The lower four bits of the Modem Control Register (MCR) directly manipulate the outputs of the UART. * The DTR (bit 0), RTS (bit 1), OUT1 (bit 2), and OUT2 (bit 3) bits are inverted and then drive the * corresponding UART outputs, dtr_n, rts_n, out1_n, and out2_n. In loopback mode, these outputs are * driven inactive high while the values in these locations are internally looped back to the inputs. * * Note: When Auto RTS is enabled, the rts_n output is controlled in the same way, but is also gated * with the receiver FIFO threshold trigger (rts_n is inactive high when above the threshold). The * rts_n output will be de-asserted whenever RTS (bit 1) is set low. * * Note: The UART0 out1_n and out2_n outputs are not present on the pins of the chip, but the UART0 OUT1 * and OUT2 bits still function in Loopback mode. The UART1 dtr_n, out1_n, and out2_n outputs are not * present on the pins of the chip, but the UART1 DTR, OUT1, and OUT2 bits still function in Loopback * mode. * * MCR bit 4 is the Loopback bit. When set, data on the sout line is held high, while serial data output * is looped back to the sin line, internally. In this mode all the interrupts are fully functional. This * feature is used for diagnostic purposes. Also, in loopback mode, the modem control inputs (dsr_n, * cts_n, ri_n, dcd_n) are disconnected and the four modem control outputs (dtr_n, rts_n, out1_n, out1_n) * are looped back to the inputs, internally. * * MCR bit 5 is the Auto Flow Control Enable (AFCE) bit. When FIFOs are enabled and this bit is set, * 16750-compatible Auto RTS and Auto CTS serial data flow control features are enabled. * * Auto RTS becomes active when the following occurs: * 1. MCR bit 1 is set * 2. FIFOs are enabled by setting FIFO Control Register (FCR) bit 0 * 3. MCR bit 5 is set (must be set after FCR bit 0) * * When active, the rts_n output is forced inactive-high when the receiver FIFO level reaches the * threshold set by FCR[7:6]. When rts_n is connected to the cts_n input of another UART device, the * other UART stops sending serial data until the receiver FIFO has available space. * * The selectable receiver FIFO threshold values are: 1, 1/4, 1/2, and 2 less than full. Since one * additional character may be transmitted to the UART after rts_n has become inactive (due to data * already having entered the transmitter block in the other UART), setting the threshold to 2 less * than full allows maximum use of the FIFO with a safety zone of one character. * * Once the receiver FIFO becomes completely empty by reading the Receiver Buffer Register (RBR), rts_n * again becomes active-low, signalling the other UART to continue sending data. It is important to note * that, even if everything else is set to Enabled and the correct MCR bits are set, if the FIFOs are * disabled through FCR[0], Auto Flow Control is also disabled. When Auto RTS is disabled or inactive, * rts_n is controlled solely by MCR[1]. * * Auto CTS becomes active when the following occurs: * 1. FIFOs are enabled by setting FIFO Control Register (FCR) bit 0 * 2. MCR bit 5 is set (must be set after FCR bit 0) * * When active, the UART transmitter is disabled whenever the cts_n input becomes inactive-high. This * prevents overflowing the FIFO of the receiving UART. * * Note that, if the cts_n input is not inactivated before the middle of the last stop bit, another * character is transmitted before the transmitter is disabled. While the transmitter is disabled, the * transmitter FIFO can still be written to, and even overflowed. Therefore, when using this mode, either * the true FIFO depth (64 characters) must be known to software, or the Programmable THRE Interrupt mode * must be enabled to access the FIFO full status through the Line Status Register. When using the FIFO * full status, software can poll this before each write to the Transmitter FIFO. * * Note: FIFO full status is also available in the UART Status Register (USR) or the actual level of the * FIFO may be read through the Transmit FIFO Level (TFL) register. * * When the cts_n input becomes active-low again, transmission resumes. It is important to note that, * even if everything else is set to Enabled, Auto Flow Control is also disabled if the FIFOs are * disabled through FCR[0]. When Auto CTS is disabled or inactive, the transmitter is unaffected by * cts_n. */ union cvmx_mio_uartx_mcr { uint64_t u64; struct cvmx_mio_uartx_mcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_6_63 : 58; uint64_t afce : 1; /**< Auto Flow Control Enable bit */ uint64_t loop : 1; /**< Loopback bit */ uint64_t out2 : 1; /**< OUT2 output bit */ uint64_t out1 : 1; /**< OUT1 output bit */ uint64_t rts : 1; /**< Request To Send output bit */ uint64_t dtr : 1; /**< Data Terminal Ready output bit */ #else uint64_t dtr : 1; uint64_t rts : 1; uint64_t out1 : 1; uint64_t out2 : 1; uint64_t loop : 1; uint64_t afce : 1; uint64_t reserved_6_63 : 58; #endif } s; struct cvmx_mio_uartx_mcr_s cn30xx; struct cvmx_mio_uartx_mcr_s cn31xx; struct cvmx_mio_uartx_mcr_s cn38xx; struct cvmx_mio_uartx_mcr_s cn38xxp2; struct cvmx_mio_uartx_mcr_s cn50xx; struct cvmx_mio_uartx_mcr_s cn52xx; struct cvmx_mio_uartx_mcr_s cn52xxp1; struct cvmx_mio_uartx_mcr_s cn56xx; struct cvmx_mio_uartx_mcr_s cn56xxp1; struct cvmx_mio_uartx_mcr_s cn58xx; struct cvmx_mio_uartx_mcr_s cn58xxp1; struct cvmx_mio_uartx_mcr_s cn63xx; struct cvmx_mio_uartx_mcr_s cn63xxp1; }; typedef union cvmx_mio_uartx_mcr cvmx_mio_uartx_mcr_t; typedef cvmx_mio_uartx_mcr_t cvmx_uart_mcr_t; /** * cvmx_mio_uart#_msr * * MIO_UARTX_MSR = MIO UARTX Modem Status Register * * The Modem Status Register (MSR) contains the current status of the modem control input lines and if * they changed. * * DCTS (bit 0), DDSR (bit 1), and DDCD (bit 3) bits record whether the modem control lines (cts_n, * dsr_n, and dcd_n) have changed since the last time the user read the MSR. TERI (bit 2) indicates ri_n * has changed from an active-low, to an inactive-high state since the last time the MSR was read. In * Loopback mode, DCTS reflects changes on MCR bit 1 (RTS), DDSR reflects changes on MCR bit 0 (DTR), and * DDCD reflects changes on MCR bit 3 (Out2), while TERI reflects when MCR bit 2 (Out1) has changed state * from a high to a low. * * Note: if the DCTS bit is not set and the cts_n signal is asserted (low) and a reset occurs (software * or otherwise), then the DCTS bit will get set when the reset is removed if the cts_n signal remains * asserted. * * The CTS, DSR, RI, and DCD Modem Status bits contain information on the current state of the modem * control lines. CTS (bit 4) is the compliment of cts_n, DSR (bit 5) is the compliment of dsr_n, RI * (bit 6) is the compliment of ri_n, and DCD (bit 7) is the compliment of dcd_n. In Loopback mode, CTS * is the same as MCR bit 1 (RTS), DSR is the same as MCR bit 0 (DTR), RI is the same as MCR bit 2 * (Out1), and DCD is the same as MCR bit 3 (Out2). * * Note: The UART0 dsr_n and ri_n inputs are internally tied to power and not present on the pins of chip. * Thus the UART0 DSR and RI bits will be '0' when not in Loopback mode. The UART1 dsr_n, ri_n, and dcd_n * inputs are internally tied to power and not present on the pins of chip. Thus the UART1 DSR, RI, and * DCD bits will be '0' when not in Loopback mode. */ union cvmx_mio_uartx_msr { uint64_t u64; struct cvmx_mio_uartx_msr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dcd : 1; /**< Data Carrier Detect input bit */ uint64_t ri : 1; /**< Ring Indicator input bit */ uint64_t dsr : 1; /**< Data Set Ready input bit */ uint64_t cts : 1; /**< Clear To Send input bit */ uint64_t ddcd : 1; /**< Delta Data Carrier Detect bit */ uint64_t teri : 1; /**< Trailing Edge of Ring Indicator bit */ uint64_t ddsr : 1; /**< Delta Data Set Ready bit */ uint64_t dcts : 1; /**< Delta Clear To Send bit */ #else uint64_t dcts : 1; uint64_t ddsr : 1; uint64_t teri : 1; uint64_t ddcd : 1; uint64_t cts : 1; uint64_t dsr : 1; uint64_t ri : 1; uint64_t dcd : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_msr_s cn30xx; struct cvmx_mio_uartx_msr_s cn31xx; struct cvmx_mio_uartx_msr_s cn38xx; struct cvmx_mio_uartx_msr_s cn38xxp2; struct cvmx_mio_uartx_msr_s cn50xx; struct cvmx_mio_uartx_msr_s cn52xx; struct cvmx_mio_uartx_msr_s cn52xxp1; struct cvmx_mio_uartx_msr_s cn56xx; struct cvmx_mio_uartx_msr_s cn56xxp1; struct cvmx_mio_uartx_msr_s cn58xx; struct cvmx_mio_uartx_msr_s cn58xxp1; struct cvmx_mio_uartx_msr_s cn63xx; struct cvmx_mio_uartx_msr_s cn63xxp1; }; typedef union cvmx_mio_uartx_msr cvmx_mio_uartx_msr_t; typedef cvmx_mio_uartx_msr_t cvmx_uart_msr_t; /** * cvmx_mio_uart#_rbr * * MIO_UARTX_RBR = MIO UARTX Receive Buffer Register * * The Receive Buffer Register (RBR) is a read-only register that contains the data byte received on the * serial input port (sin). The data in this register is valid only if the Data Ready (DR) bit in the * Line status Register (LSR) is set. When the FIFOs are programmed OFF, the data in the RBR must be * read before the next data arrives, otherwise it is overwritten, resulting in an overrun error. When * the FIFOs are programmed ON, this register accesses the head of the receive FIFO. If the receive FIFO * is full (64 characters) and this register is not read before the next data character arrives, then the * data already in the FIFO is preserved, but any incoming data is lost. An overrun error also occurs. * * Note: The Divisor Latch Address Bit (DLAB) of the Line Control Register (LCR) must be clear to access * this register. * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * RBR, THR, and DLL registers are the same. */ union cvmx_mio_uartx_rbr { uint64_t u64; struct cvmx_mio_uartx_rbr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t rbr : 8; /**< Receive Buffer Register */ #else uint64_t rbr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_rbr_s cn30xx; struct cvmx_mio_uartx_rbr_s cn31xx; struct cvmx_mio_uartx_rbr_s cn38xx; struct cvmx_mio_uartx_rbr_s cn38xxp2; struct cvmx_mio_uartx_rbr_s cn50xx; struct cvmx_mio_uartx_rbr_s cn52xx; struct cvmx_mio_uartx_rbr_s cn52xxp1; struct cvmx_mio_uartx_rbr_s cn56xx; struct cvmx_mio_uartx_rbr_s cn56xxp1; struct cvmx_mio_uartx_rbr_s cn58xx; struct cvmx_mio_uartx_rbr_s cn58xxp1; struct cvmx_mio_uartx_rbr_s cn63xx; struct cvmx_mio_uartx_rbr_s cn63xxp1; }; typedef union cvmx_mio_uartx_rbr cvmx_mio_uartx_rbr_t; typedef cvmx_mio_uartx_rbr_t cvmx_uart_rbr_t; /** * cvmx_mio_uart#_rfl * * MIO_UARTX_RFL = MIO UARTX Receive FIFO Level Register * * The Receive FIFO Level Register (RFL) indicates the number of data entries in the receive FIFO. */ union cvmx_mio_uartx_rfl { uint64_t u64; struct cvmx_mio_uartx_rfl_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_7_63 : 57; uint64_t rfl : 7; /**< Receive FIFO Level Register */ #else uint64_t rfl : 7; uint64_t reserved_7_63 : 57; #endif } s; struct cvmx_mio_uartx_rfl_s cn30xx; struct cvmx_mio_uartx_rfl_s cn31xx; struct cvmx_mio_uartx_rfl_s cn38xx; struct cvmx_mio_uartx_rfl_s cn38xxp2; struct cvmx_mio_uartx_rfl_s cn50xx; struct cvmx_mio_uartx_rfl_s cn52xx; struct cvmx_mio_uartx_rfl_s cn52xxp1; struct cvmx_mio_uartx_rfl_s cn56xx; struct cvmx_mio_uartx_rfl_s cn56xxp1; struct cvmx_mio_uartx_rfl_s cn58xx; struct cvmx_mio_uartx_rfl_s cn58xxp1; struct cvmx_mio_uartx_rfl_s cn63xx; struct cvmx_mio_uartx_rfl_s cn63xxp1; }; typedef union cvmx_mio_uartx_rfl cvmx_mio_uartx_rfl_t; typedef cvmx_mio_uartx_rfl_t cvmx_uart_rfl_t; /** * cvmx_mio_uart#_rfw * * MIO_UARTX_RFW = MIO UARTX Receive FIFO Write Register * * The Receive FIFO Write Register (RFW) is only valid when FIFO access mode is enabled (FAR bit 0 is * set). When FIFOs are enabled, this register is used to write data to the receive FIFO. Each * consecutive write pushes the new data to the next write location in the receive FIFO. When FIFOs are * not enabled, this register is used to write data to the RBR. */ union cvmx_mio_uartx_rfw { uint64_t u64; struct cvmx_mio_uartx_rfw_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t rffe : 1; /**< Receive FIFO Framing Error */ uint64_t rfpe : 1; /**< Receive FIFO Parity Error */ uint64_t rfwd : 8; /**< Receive FIFO Write Data */ #else uint64_t rfwd : 8; uint64_t rfpe : 1; uint64_t rffe : 1; uint64_t reserved_10_63 : 54; #endif } s; struct cvmx_mio_uartx_rfw_s cn30xx; struct cvmx_mio_uartx_rfw_s cn31xx; struct cvmx_mio_uartx_rfw_s cn38xx; struct cvmx_mio_uartx_rfw_s cn38xxp2; struct cvmx_mio_uartx_rfw_s cn50xx; struct cvmx_mio_uartx_rfw_s cn52xx; struct cvmx_mio_uartx_rfw_s cn52xxp1; struct cvmx_mio_uartx_rfw_s cn56xx; struct cvmx_mio_uartx_rfw_s cn56xxp1; struct cvmx_mio_uartx_rfw_s cn58xx; struct cvmx_mio_uartx_rfw_s cn58xxp1; struct cvmx_mio_uartx_rfw_s cn63xx; struct cvmx_mio_uartx_rfw_s cn63xxp1; }; typedef union cvmx_mio_uartx_rfw cvmx_mio_uartx_rfw_t; typedef cvmx_mio_uartx_rfw_t cvmx_uart_rfw_t; /** * cvmx_mio_uart#_sbcr * * MIO_UARTX_SBCR = MIO UARTX Shadow Break Control Register * * The Shadow Break Control Register (SBCR) is a shadow register for the BREAK bit (LCR bit 6) that can * be used to remove the burden of having to perform a read-modify-write on the LCR. */ union cvmx_mio_uartx_sbcr { uint64_t u64; struct cvmx_mio_uartx_sbcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t sbcr : 1; /**< Shadow Break Control */ #else uint64_t sbcr : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uartx_sbcr_s cn30xx; struct cvmx_mio_uartx_sbcr_s cn31xx; struct cvmx_mio_uartx_sbcr_s cn38xx; struct cvmx_mio_uartx_sbcr_s cn38xxp2; struct cvmx_mio_uartx_sbcr_s cn50xx; struct cvmx_mio_uartx_sbcr_s cn52xx; struct cvmx_mio_uartx_sbcr_s cn52xxp1; struct cvmx_mio_uartx_sbcr_s cn56xx; struct cvmx_mio_uartx_sbcr_s cn56xxp1; struct cvmx_mio_uartx_sbcr_s cn58xx; struct cvmx_mio_uartx_sbcr_s cn58xxp1; struct cvmx_mio_uartx_sbcr_s cn63xx; struct cvmx_mio_uartx_sbcr_s cn63xxp1; }; typedef union cvmx_mio_uartx_sbcr cvmx_mio_uartx_sbcr_t; typedef cvmx_mio_uartx_sbcr_t cvmx_uart_sbcr_t; /** * cvmx_mio_uart#_scr * * MIO_UARTX_SCR = MIO UARTX Scratchpad Register * * The Scratchpad Register (SCR) is an 8-bit read/write register for programmers to use as a temporary * storage space. */ union cvmx_mio_uartx_scr { uint64_t u64; struct cvmx_mio_uartx_scr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t scr : 8; /**< Scratchpad Register */ #else uint64_t scr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_scr_s cn30xx; struct cvmx_mio_uartx_scr_s cn31xx; struct cvmx_mio_uartx_scr_s cn38xx; struct cvmx_mio_uartx_scr_s cn38xxp2; struct cvmx_mio_uartx_scr_s cn50xx; struct cvmx_mio_uartx_scr_s cn52xx; struct cvmx_mio_uartx_scr_s cn52xxp1; struct cvmx_mio_uartx_scr_s cn56xx; struct cvmx_mio_uartx_scr_s cn56xxp1; struct cvmx_mio_uartx_scr_s cn58xx; struct cvmx_mio_uartx_scr_s cn58xxp1; struct cvmx_mio_uartx_scr_s cn63xx; struct cvmx_mio_uartx_scr_s cn63xxp1; }; typedef union cvmx_mio_uartx_scr cvmx_mio_uartx_scr_t; typedef cvmx_mio_uartx_scr_t cvmx_uart_scr_t; /** * cvmx_mio_uart#_sfe * * MIO_UARTX_SFE = MIO UARTX Shadow FIFO Enable Register * * The Shadow FIFO Enable Register (SFE) is a shadow register for the FIFO enable bit (FCR bit 0) that * can be used to remove the burden of having to store the previously written value to the FCR in memory * and having to mask this value so that only the FIFO enable bit gets updated. */ union cvmx_mio_uartx_sfe { uint64_t u64; struct cvmx_mio_uartx_sfe_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t sfe : 1; /**< Shadow FIFO Enable */ #else uint64_t sfe : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uartx_sfe_s cn30xx; struct cvmx_mio_uartx_sfe_s cn31xx; struct cvmx_mio_uartx_sfe_s cn38xx; struct cvmx_mio_uartx_sfe_s cn38xxp2; struct cvmx_mio_uartx_sfe_s cn50xx; struct cvmx_mio_uartx_sfe_s cn52xx; struct cvmx_mio_uartx_sfe_s cn52xxp1; struct cvmx_mio_uartx_sfe_s cn56xx; struct cvmx_mio_uartx_sfe_s cn56xxp1; struct cvmx_mio_uartx_sfe_s cn58xx; struct cvmx_mio_uartx_sfe_s cn58xxp1; struct cvmx_mio_uartx_sfe_s cn63xx; struct cvmx_mio_uartx_sfe_s cn63xxp1; }; typedef union cvmx_mio_uartx_sfe cvmx_mio_uartx_sfe_t; typedef cvmx_mio_uartx_sfe_t cvmx_uart_sfe_t; /** * cvmx_mio_uart#_srr * * MIO_UARTX_SRR = MIO UARTX Software Reset Register * * The Software Reset Register (SRR) is a write-only register that resets the UART and/or the receive * FIFO and/or the transmit FIFO. * * Bit 0 of the SRR is the UART Soft Reset (USR) bit. Setting this bit resets the UART. * * Bit 1 of the SRR is a shadow copy of the RX FIFO Reset bit (FCR bit 1). This can be used to remove * the burden on software having to store previously written FCR values (which are pretty static) just * to reset the receive FIFO. * * Bit 2 of the SRR is a shadow copy of the TX FIFO Reset bit (FCR bit 2). This can be used to remove * the burden on software having to store previously written FCR values (which are pretty static) just * to reset the transmit FIFO. */ union cvmx_mio_uartx_srr { uint64_t u64; struct cvmx_mio_uartx_srr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_3_63 : 61; uint64_t stfr : 1; /**< Shadow TX FIFO Reset */ uint64_t srfr : 1; /**< Shadow RX FIFO Reset */ uint64_t usr : 1; /**< UART Soft Reset */ #else uint64_t usr : 1; uint64_t srfr : 1; uint64_t stfr : 1; uint64_t reserved_3_63 : 61; #endif } s; struct cvmx_mio_uartx_srr_s cn30xx; struct cvmx_mio_uartx_srr_s cn31xx; struct cvmx_mio_uartx_srr_s cn38xx; struct cvmx_mio_uartx_srr_s cn38xxp2; struct cvmx_mio_uartx_srr_s cn50xx; struct cvmx_mio_uartx_srr_s cn52xx; struct cvmx_mio_uartx_srr_s cn52xxp1; struct cvmx_mio_uartx_srr_s cn56xx; struct cvmx_mio_uartx_srr_s cn56xxp1; struct cvmx_mio_uartx_srr_s cn58xx; struct cvmx_mio_uartx_srr_s cn58xxp1; struct cvmx_mio_uartx_srr_s cn63xx; struct cvmx_mio_uartx_srr_s cn63xxp1; }; typedef union cvmx_mio_uartx_srr cvmx_mio_uartx_srr_t; typedef cvmx_mio_uartx_srr_t cvmx_uart_srr_t; /** * cvmx_mio_uart#_srt * * MIO_UARTX_SRT = MIO UARTX Shadow RX Trigger Register * * The Shadow RX Trigger Register (SRT) is a shadow register for the RX Trigger bits (FCR bits 7:6) that * can be used to remove the burden of having to store the previously written value to the FCR in memory * and having to mask this value so that only the RX Trigger bits get updated. */ union cvmx_mio_uartx_srt { uint64_t u64; struct cvmx_mio_uartx_srt_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t srt : 2; /**< Shadow RX Trigger */ #else uint64_t srt : 2; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_uartx_srt_s cn30xx; struct cvmx_mio_uartx_srt_s cn31xx; struct cvmx_mio_uartx_srt_s cn38xx; struct cvmx_mio_uartx_srt_s cn38xxp2; struct cvmx_mio_uartx_srt_s cn50xx; struct cvmx_mio_uartx_srt_s cn52xx; struct cvmx_mio_uartx_srt_s cn52xxp1; struct cvmx_mio_uartx_srt_s cn56xx; struct cvmx_mio_uartx_srt_s cn56xxp1; struct cvmx_mio_uartx_srt_s cn58xx; struct cvmx_mio_uartx_srt_s cn58xxp1; struct cvmx_mio_uartx_srt_s cn63xx; struct cvmx_mio_uartx_srt_s cn63xxp1; }; typedef union cvmx_mio_uartx_srt cvmx_mio_uartx_srt_t; typedef cvmx_mio_uartx_srt_t cvmx_uart_srt_t; /** * cvmx_mio_uart#_srts * * MIO_UARTX_SRTS = MIO UARTX Shadow Request To Send Register * * The Shadow Request To Send Register (SRTS) is a shadow register for the RTS bit (MCR bit 1) that can * be used to remove the burden of having to perform a read-modify-write on the MCR. */ union cvmx_mio_uartx_srts { uint64_t u64; struct cvmx_mio_uartx_srts_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t srts : 1; /**< Shadow Request To Send */ #else uint64_t srts : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uartx_srts_s cn30xx; struct cvmx_mio_uartx_srts_s cn31xx; struct cvmx_mio_uartx_srts_s cn38xx; struct cvmx_mio_uartx_srts_s cn38xxp2; struct cvmx_mio_uartx_srts_s cn50xx; struct cvmx_mio_uartx_srts_s cn52xx; struct cvmx_mio_uartx_srts_s cn52xxp1; struct cvmx_mio_uartx_srts_s cn56xx; struct cvmx_mio_uartx_srts_s cn56xxp1; struct cvmx_mio_uartx_srts_s cn58xx; struct cvmx_mio_uartx_srts_s cn58xxp1; struct cvmx_mio_uartx_srts_s cn63xx; struct cvmx_mio_uartx_srts_s cn63xxp1; }; typedef union cvmx_mio_uartx_srts cvmx_mio_uartx_srts_t; typedef cvmx_mio_uartx_srts_t cvmx_uart_srts_t; /** * cvmx_mio_uart#_stt * * MIO_UARTX_STT = MIO UARTX Shadow TX Trigger Register * * The Shadow TX Trigger Register (STT) is a shadow register for the TX Trigger bits (FCR bits 5:4) that * can be used to remove the burden of having to store the previously written value to the FCR in memory * and having to mask this value so that only the TX Trigger bits get updated. */ union cvmx_mio_uartx_stt { uint64_t u64; struct cvmx_mio_uartx_stt_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t stt : 2; /**< Shadow TX Trigger */ #else uint64_t stt : 2; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_uartx_stt_s cn30xx; struct cvmx_mio_uartx_stt_s cn31xx; struct cvmx_mio_uartx_stt_s cn38xx; struct cvmx_mio_uartx_stt_s cn38xxp2; struct cvmx_mio_uartx_stt_s cn50xx; struct cvmx_mio_uartx_stt_s cn52xx; struct cvmx_mio_uartx_stt_s cn52xxp1; struct cvmx_mio_uartx_stt_s cn56xx; struct cvmx_mio_uartx_stt_s cn56xxp1; struct cvmx_mio_uartx_stt_s cn58xx; struct cvmx_mio_uartx_stt_s cn58xxp1; struct cvmx_mio_uartx_stt_s cn63xx; struct cvmx_mio_uartx_stt_s cn63xxp1; }; typedef union cvmx_mio_uartx_stt cvmx_mio_uartx_stt_t; typedef cvmx_mio_uartx_stt_t cvmx_uart_stt_t; /** * cvmx_mio_uart#_tfl * * MIO_UARTX_TFL = MIO UARTX Transmit FIFO Level Register * * The Transmit FIFO Level Register (TFL) indicates the number of data entries in the transmit FIFO. */ union cvmx_mio_uartx_tfl { uint64_t u64; struct cvmx_mio_uartx_tfl_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_7_63 : 57; uint64_t tfl : 7; /**< Transmit FIFO Level Register */ #else uint64_t tfl : 7; uint64_t reserved_7_63 : 57; #endif } s; struct cvmx_mio_uartx_tfl_s cn30xx; struct cvmx_mio_uartx_tfl_s cn31xx; struct cvmx_mio_uartx_tfl_s cn38xx; struct cvmx_mio_uartx_tfl_s cn38xxp2; struct cvmx_mio_uartx_tfl_s cn50xx; struct cvmx_mio_uartx_tfl_s cn52xx; struct cvmx_mio_uartx_tfl_s cn52xxp1; struct cvmx_mio_uartx_tfl_s cn56xx; struct cvmx_mio_uartx_tfl_s cn56xxp1; struct cvmx_mio_uartx_tfl_s cn58xx; struct cvmx_mio_uartx_tfl_s cn58xxp1; struct cvmx_mio_uartx_tfl_s cn63xx; struct cvmx_mio_uartx_tfl_s cn63xxp1; }; typedef union cvmx_mio_uartx_tfl cvmx_mio_uartx_tfl_t; typedef cvmx_mio_uartx_tfl_t cvmx_uart_tfl_t; /** * cvmx_mio_uart#_tfr * * MIO_UARTX_TFR = MIO UARTX Transmit FIFO Read Register * * The Transmit FIFO Read Register (TFR) is only valid when FIFO access mode is enabled (FAR bit 0 is * set). When FIFOs are enabled, reading this register gives the data at the top of the transmit FIFO. * Each consecutive read pops the transmit FIFO and gives the next data value that is currently at the * top of the FIFO. When FIFOs are not enabled, reading this register gives the data in the THR. */ union cvmx_mio_uartx_tfr { uint64_t u64; struct cvmx_mio_uartx_tfr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t tfr : 8; /**< Transmit FIFO Read Register */ #else uint64_t tfr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_tfr_s cn30xx; struct cvmx_mio_uartx_tfr_s cn31xx; struct cvmx_mio_uartx_tfr_s cn38xx; struct cvmx_mio_uartx_tfr_s cn38xxp2; struct cvmx_mio_uartx_tfr_s cn50xx; struct cvmx_mio_uartx_tfr_s cn52xx; struct cvmx_mio_uartx_tfr_s cn52xxp1; struct cvmx_mio_uartx_tfr_s cn56xx; struct cvmx_mio_uartx_tfr_s cn56xxp1; struct cvmx_mio_uartx_tfr_s cn58xx; struct cvmx_mio_uartx_tfr_s cn58xxp1; struct cvmx_mio_uartx_tfr_s cn63xx; struct cvmx_mio_uartx_tfr_s cn63xxp1; }; typedef union cvmx_mio_uartx_tfr cvmx_mio_uartx_tfr_t; typedef cvmx_mio_uartx_tfr_t cvmx_uart_tfr_t; /** * cvmx_mio_uart#_thr * * MIO_UARTX_THR = MIO UARTX Transmit Holding Register * * Transmit Holding Register (THR) is a write-only register that contains data to be transmitted on the * serial output port (sout). Data can be written to the THR any time that the THR Empty (THRE) bit of * the Line Status Register (LSR) is set. * * If FIFOs are not enabled and THRE is set, writing a single character to the THR clears the THRE. Any * additional writes to the THR before the THRE is set again causes the THR data to be overwritten. * * If FIFOs are enabled and THRE is set (and Programmable THRE mode disabled), 64 characters of data may * be written to the THR before the FIFO is full. Any attempt to write data when the FIFO is full results * in the write data being lost. * * Note: The Divisor Latch Address Bit (DLAB) of the Line Control Register (LCR) must be clear to access * this register. * * Note: The address below is an alias to simplify these CSR descriptions. It should be known that the * RBR, THR, and DLL registers are the same. */ union cvmx_mio_uartx_thr { uint64_t u64; struct cvmx_mio_uartx_thr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t thr : 8; /**< Transmit Holding Register */ #else uint64_t thr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uartx_thr_s cn30xx; struct cvmx_mio_uartx_thr_s cn31xx; struct cvmx_mio_uartx_thr_s cn38xx; struct cvmx_mio_uartx_thr_s cn38xxp2; struct cvmx_mio_uartx_thr_s cn50xx; struct cvmx_mio_uartx_thr_s cn52xx; struct cvmx_mio_uartx_thr_s cn52xxp1; struct cvmx_mio_uartx_thr_s cn56xx; struct cvmx_mio_uartx_thr_s cn56xxp1; struct cvmx_mio_uartx_thr_s cn58xx; struct cvmx_mio_uartx_thr_s cn58xxp1; struct cvmx_mio_uartx_thr_s cn63xx; struct cvmx_mio_uartx_thr_s cn63xxp1; }; typedef union cvmx_mio_uartx_thr cvmx_mio_uartx_thr_t; typedef cvmx_mio_uartx_thr_t cvmx_uart_thr_t; /** * cvmx_mio_uart#_usr * * MIO_UARTX_USR = MIO UARTX UART Status Register * * The UART Status Register (USR) contains UART status information. * * USR bit 0 is the BUSY bit. When set this bit indicates that a serial transfer is in progress, when * clear it indicates that the UART is idle or inactive. * * Note: In PASS3, the BUSY bit will always be clear. * * USR bits 1-4 indicate the following FIFO status: TX FIFO Not Full (TFNF), TX FIFO Empty (TFE), RX * FIFO Not Empty (RFNE), and RX FIFO Full (RFF). */ union cvmx_mio_uartx_usr { uint64_t u64; struct cvmx_mio_uartx_usr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_5_63 : 59; uint64_t rff : 1; /**< RX FIFO Full */ uint64_t rfne : 1; /**< RX FIFO Not Empty */ uint64_t tfe : 1; /**< TX FIFO Empty */ uint64_t tfnf : 1; /**< TX FIFO Not Full */ uint64_t busy : 1; /**< Busy bit (always 0 in PASS3) */ #else uint64_t busy : 1; uint64_t tfnf : 1; uint64_t tfe : 1; uint64_t rfne : 1; uint64_t rff : 1; uint64_t reserved_5_63 : 59; #endif } s; struct cvmx_mio_uartx_usr_s cn30xx; struct cvmx_mio_uartx_usr_s cn31xx; struct cvmx_mio_uartx_usr_s cn38xx; struct cvmx_mio_uartx_usr_s cn38xxp2; struct cvmx_mio_uartx_usr_s cn50xx; struct cvmx_mio_uartx_usr_s cn52xx; struct cvmx_mio_uartx_usr_s cn52xxp1; struct cvmx_mio_uartx_usr_s cn56xx; struct cvmx_mio_uartx_usr_s cn56xxp1; struct cvmx_mio_uartx_usr_s cn58xx; struct cvmx_mio_uartx_usr_s cn58xxp1; struct cvmx_mio_uartx_usr_s cn63xx; struct cvmx_mio_uartx_usr_s cn63xxp1; }; typedef union cvmx_mio_uartx_usr cvmx_mio_uartx_usr_t; typedef cvmx_mio_uartx_usr_t cvmx_uart_usr_t; /** * cvmx_mio_uart2_dlh */ union cvmx_mio_uart2_dlh { uint64_t u64; struct cvmx_mio_uart2_dlh_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dlh : 8; /**< Divisor Latch High Register */ #else uint64_t dlh : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_dlh_s cn52xx; struct cvmx_mio_uart2_dlh_s cn52xxp1; }; typedef union cvmx_mio_uart2_dlh cvmx_mio_uart2_dlh_t; /** * cvmx_mio_uart2_dll */ union cvmx_mio_uart2_dll { uint64_t u64; struct cvmx_mio_uart2_dll_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dll : 8; /**< Divisor Latch Low Register */ #else uint64_t dll : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_dll_s cn52xx; struct cvmx_mio_uart2_dll_s cn52xxp1; }; typedef union cvmx_mio_uart2_dll cvmx_mio_uart2_dll_t; /** * cvmx_mio_uart2_far */ union cvmx_mio_uart2_far { uint64_t u64; struct cvmx_mio_uart2_far_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t far : 1; /**< FIFO Access Register */ #else uint64_t far : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uart2_far_s cn52xx; struct cvmx_mio_uart2_far_s cn52xxp1; }; typedef union cvmx_mio_uart2_far cvmx_mio_uart2_far_t; /** * cvmx_mio_uart2_fcr */ union cvmx_mio_uart2_fcr { uint64_t u64; struct cvmx_mio_uart2_fcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t rxtrig : 2; /**< RX Trigger */ uint64_t txtrig : 2; /**< TX Trigger */ uint64_t reserved_3_3 : 1; uint64_t txfr : 1; /**< TX FIFO reset */ uint64_t rxfr : 1; /**< RX FIFO reset */ uint64_t en : 1; /**< FIFO enable */ #else uint64_t en : 1; uint64_t rxfr : 1; uint64_t txfr : 1; uint64_t reserved_3_3 : 1; uint64_t txtrig : 2; uint64_t rxtrig : 2; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_fcr_s cn52xx; struct cvmx_mio_uart2_fcr_s cn52xxp1; }; typedef union cvmx_mio_uart2_fcr cvmx_mio_uart2_fcr_t; /** * cvmx_mio_uart2_htx */ union cvmx_mio_uart2_htx { uint64_t u64; struct cvmx_mio_uart2_htx_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t htx : 1; /**< Halt TX */ #else uint64_t htx : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uart2_htx_s cn52xx; struct cvmx_mio_uart2_htx_s cn52xxp1; }; typedef union cvmx_mio_uart2_htx cvmx_mio_uart2_htx_t; /** * cvmx_mio_uart2_ier */ union cvmx_mio_uart2_ier { uint64_t u64; struct cvmx_mio_uart2_ier_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t ptime : 1; /**< Programmable THRE Interrupt mode enable */ uint64_t reserved_4_6 : 3; uint64_t edssi : 1; /**< Enable Modem Status Interrupt */ uint64_t elsi : 1; /**< Enable Receiver Line Status Interrupt */ uint64_t etbei : 1; /**< Enable Transmitter Holding Register Empty Interrupt */ uint64_t erbfi : 1; /**< Enable Received Data Available Interrupt */ #else uint64_t erbfi : 1; uint64_t etbei : 1; uint64_t elsi : 1; uint64_t edssi : 1; uint64_t reserved_4_6 : 3; uint64_t ptime : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_ier_s cn52xx; struct cvmx_mio_uart2_ier_s cn52xxp1; }; typedef union cvmx_mio_uart2_ier cvmx_mio_uart2_ier_t; /** * cvmx_mio_uart2_iir */ union cvmx_mio_uart2_iir { uint64_t u64; struct cvmx_mio_uart2_iir_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t fen : 2; /**< FIFO-enabled bits */ uint64_t reserved_4_5 : 2; uint64_t iid : 4; /**< Interrupt ID */ #else uint64_t iid : 4; uint64_t reserved_4_5 : 2; uint64_t fen : 2; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_iir_s cn52xx; struct cvmx_mio_uart2_iir_s cn52xxp1; }; typedef union cvmx_mio_uart2_iir cvmx_mio_uart2_iir_t; /** * cvmx_mio_uart2_lcr */ union cvmx_mio_uart2_lcr { uint64_t u64; struct cvmx_mio_uart2_lcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dlab : 1; /**< Divisor Latch Address bit */ uint64_t brk : 1; /**< Break Control bit */ uint64_t reserved_5_5 : 1; uint64_t eps : 1; /**< Even Parity Select bit */ uint64_t pen : 1; /**< Parity Enable bit */ uint64_t stop : 1; /**< Stop Control bit */ uint64_t cls : 2; /**< Character Length Select */ #else uint64_t cls : 2; uint64_t stop : 1; uint64_t pen : 1; uint64_t eps : 1; uint64_t reserved_5_5 : 1; uint64_t brk : 1; uint64_t dlab : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_lcr_s cn52xx; struct cvmx_mio_uart2_lcr_s cn52xxp1; }; typedef union cvmx_mio_uart2_lcr cvmx_mio_uart2_lcr_t; /** * cvmx_mio_uart2_lsr */ union cvmx_mio_uart2_lsr { uint64_t u64; struct cvmx_mio_uart2_lsr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t ferr : 1; /**< Error in Receiver FIFO bit */ uint64_t temt : 1; /**< Transmitter Empty bit */ uint64_t thre : 1; /**< Transmitter Holding Register Empty bit */ uint64_t bi : 1; /**< Break Interrupt bit */ uint64_t fe : 1; /**< Framing Error bit */ uint64_t pe : 1; /**< Parity Error bit */ uint64_t oe : 1; /**< Overrun Error bit */ uint64_t dr : 1; /**< Data Ready bit */ #else uint64_t dr : 1; uint64_t oe : 1; uint64_t pe : 1; uint64_t fe : 1; uint64_t bi : 1; uint64_t thre : 1; uint64_t temt : 1; uint64_t ferr : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_lsr_s cn52xx; struct cvmx_mio_uart2_lsr_s cn52xxp1; }; typedef union cvmx_mio_uart2_lsr cvmx_mio_uart2_lsr_t; /** * cvmx_mio_uart2_mcr */ union cvmx_mio_uart2_mcr { uint64_t u64; struct cvmx_mio_uart2_mcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_6_63 : 58; uint64_t afce : 1; /**< Auto Flow Control Enable bit */ uint64_t loop : 1; /**< Loopback bit */ uint64_t out2 : 1; /**< OUT2 output bit */ uint64_t out1 : 1; /**< OUT1 output bit */ uint64_t rts : 1; /**< Request To Send output bit */ uint64_t dtr : 1; /**< Data Terminal Ready output bit */ #else uint64_t dtr : 1; uint64_t rts : 1; uint64_t out1 : 1; uint64_t out2 : 1; uint64_t loop : 1; uint64_t afce : 1; uint64_t reserved_6_63 : 58; #endif } s; struct cvmx_mio_uart2_mcr_s cn52xx; struct cvmx_mio_uart2_mcr_s cn52xxp1; }; typedef union cvmx_mio_uart2_mcr cvmx_mio_uart2_mcr_t; /** * cvmx_mio_uart2_msr */ union cvmx_mio_uart2_msr { uint64_t u64; struct cvmx_mio_uart2_msr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t dcd : 1; /**< Data Carrier Detect input bit */ uint64_t ri : 1; /**< Ring Indicator input bit */ uint64_t dsr : 1; /**< Data Set Ready input bit */ uint64_t cts : 1; /**< Clear To Send input bit */ uint64_t ddcd : 1; /**< Delta Data Carrier Detect bit */ uint64_t teri : 1; /**< Trailing Edge of Ring Indicator bit */ uint64_t ddsr : 1; /**< Delta Data Set Ready bit */ uint64_t dcts : 1; /**< Delta Clear To Send bit */ #else uint64_t dcts : 1; uint64_t ddsr : 1; uint64_t teri : 1; uint64_t ddcd : 1; uint64_t cts : 1; uint64_t dsr : 1; uint64_t ri : 1; uint64_t dcd : 1; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_msr_s cn52xx; struct cvmx_mio_uart2_msr_s cn52xxp1; }; typedef union cvmx_mio_uart2_msr cvmx_mio_uart2_msr_t; /** * cvmx_mio_uart2_rbr */ union cvmx_mio_uart2_rbr { uint64_t u64; struct cvmx_mio_uart2_rbr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t rbr : 8; /**< Receive Buffer Register */ #else uint64_t rbr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_rbr_s cn52xx; struct cvmx_mio_uart2_rbr_s cn52xxp1; }; typedef union cvmx_mio_uart2_rbr cvmx_mio_uart2_rbr_t; /** * cvmx_mio_uart2_rfl */ union cvmx_mio_uart2_rfl { uint64_t u64; struct cvmx_mio_uart2_rfl_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_7_63 : 57; uint64_t rfl : 7; /**< Receive FIFO Level Register */ #else uint64_t rfl : 7; uint64_t reserved_7_63 : 57; #endif } s; struct cvmx_mio_uart2_rfl_s cn52xx; struct cvmx_mio_uart2_rfl_s cn52xxp1; }; typedef union cvmx_mio_uart2_rfl cvmx_mio_uart2_rfl_t; /** * cvmx_mio_uart2_rfw */ union cvmx_mio_uart2_rfw { uint64_t u64; struct cvmx_mio_uart2_rfw_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_10_63 : 54; uint64_t rffe : 1; /**< Receive FIFO Framing Error */ uint64_t rfpe : 1; /**< Receive FIFO Parity Error */ uint64_t rfwd : 8; /**< Receive FIFO Write Data */ #else uint64_t rfwd : 8; uint64_t rfpe : 1; uint64_t rffe : 1; uint64_t reserved_10_63 : 54; #endif } s; struct cvmx_mio_uart2_rfw_s cn52xx; struct cvmx_mio_uart2_rfw_s cn52xxp1; }; typedef union cvmx_mio_uart2_rfw cvmx_mio_uart2_rfw_t; /** * cvmx_mio_uart2_sbcr */ union cvmx_mio_uart2_sbcr { uint64_t u64; struct cvmx_mio_uart2_sbcr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t sbcr : 1; /**< Shadow Break Control */ #else uint64_t sbcr : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uart2_sbcr_s cn52xx; struct cvmx_mio_uart2_sbcr_s cn52xxp1; }; typedef union cvmx_mio_uart2_sbcr cvmx_mio_uart2_sbcr_t; /** * cvmx_mio_uart2_scr */ union cvmx_mio_uart2_scr { uint64_t u64; struct cvmx_mio_uart2_scr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t scr : 8; /**< Scratchpad Register */ #else uint64_t scr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_scr_s cn52xx; struct cvmx_mio_uart2_scr_s cn52xxp1; }; typedef union cvmx_mio_uart2_scr cvmx_mio_uart2_scr_t; /** * cvmx_mio_uart2_sfe */ union cvmx_mio_uart2_sfe { uint64_t u64; struct cvmx_mio_uart2_sfe_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t sfe : 1; /**< Shadow FIFO Enable */ #else uint64_t sfe : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uart2_sfe_s cn52xx; struct cvmx_mio_uart2_sfe_s cn52xxp1; }; typedef union cvmx_mio_uart2_sfe cvmx_mio_uart2_sfe_t; /** * cvmx_mio_uart2_srr */ union cvmx_mio_uart2_srr { uint64_t u64; struct cvmx_mio_uart2_srr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_3_63 : 61; uint64_t stfr : 1; /**< Shadow TX FIFO Reset */ uint64_t srfr : 1; /**< Shadow RX FIFO Reset */ uint64_t usr : 1; /**< UART Soft Reset */ #else uint64_t usr : 1; uint64_t srfr : 1; uint64_t stfr : 1; uint64_t reserved_3_63 : 61; #endif } s; struct cvmx_mio_uart2_srr_s cn52xx; struct cvmx_mio_uart2_srr_s cn52xxp1; }; typedef union cvmx_mio_uart2_srr cvmx_mio_uart2_srr_t; /** * cvmx_mio_uart2_srt */ union cvmx_mio_uart2_srt { uint64_t u64; struct cvmx_mio_uart2_srt_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t srt : 2; /**< Shadow RX Trigger */ #else uint64_t srt : 2; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_uart2_srt_s cn52xx; struct cvmx_mio_uart2_srt_s cn52xxp1; }; typedef union cvmx_mio_uart2_srt cvmx_mio_uart2_srt_t; /** * cvmx_mio_uart2_srts */ union cvmx_mio_uart2_srts { uint64_t u64; struct cvmx_mio_uart2_srts_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_1_63 : 63; uint64_t srts : 1; /**< Shadow Request To Send */ #else uint64_t srts : 1; uint64_t reserved_1_63 : 63; #endif } s; struct cvmx_mio_uart2_srts_s cn52xx; struct cvmx_mio_uart2_srts_s cn52xxp1; }; typedef union cvmx_mio_uart2_srts cvmx_mio_uart2_srts_t; /** * cvmx_mio_uart2_stt */ union cvmx_mio_uart2_stt { uint64_t u64; struct cvmx_mio_uart2_stt_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_2_63 : 62; uint64_t stt : 2; /**< Shadow TX Trigger */ #else uint64_t stt : 2; uint64_t reserved_2_63 : 62; #endif } s; struct cvmx_mio_uart2_stt_s cn52xx; struct cvmx_mio_uart2_stt_s cn52xxp1; }; typedef union cvmx_mio_uart2_stt cvmx_mio_uart2_stt_t; /** * cvmx_mio_uart2_tfl */ union cvmx_mio_uart2_tfl { uint64_t u64; struct cvmx_mio_uart2_tfl_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_7_63 : 57; uint64_t tfl : 7; /**< Transmit FIFO Level Register */ #else uint64_t tfl : 7; uint64_t reserved_7_63 : 57; #endif } s; struct cvmx_mio_uart2_tfl_s cn52xx; struct cvmx_mio_uart2_tfl_s cn52xxp1; }; typedef union cvmx_mio_uart2_tfl cvmx_mio_uart2_tfl_t; /** * cvmx_mio_uart2_tfr */ union cvmx_mio_uart2_tfr { uint64_t u64; struct cvmx_mio_uart2_tfr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t tfr : 8; /**< Transmit FIFO Read Register */ #else uint64_t tfr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_tfr_s cn52xx; struct cvmx_mio_uart2_tfr_s cn52xxp1; }; typedef union cvmx_mio_uart2_tfr cvmx_mio_uart2_tfr_t; /** * cvmx_mio_uart2_thr */ union cvmx_mio_uart2_thr { uint64_t u64; struct cvmx_mio_uart2_thr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_8_63 : 56; uint64_t thr : 8; /**< Transmit Holding Register */ #else uint64_t thr : 8; uint64_t reserved_8_63 : 56; #endif } s; struct cvmx_mio_uart2_thr_s cn52xx; struct cvmx_mio_uart2_thr_s cn52xxp1; }; typedef union cvmx_mio_uart2_thr cvmx_mio_uart2_thr_t; /** * cvmx_mio_uart2_usr */ union cvmx_mio_uart2_usr { uint64_t u64; struct cvmx_mio_uart2_usr_s { #if __BYTE_ORDER == __BIG_ENDIAN uint64_t reserved_5_63 : 59; uint64_t rff : 1; /**< RX FIFO Full */ uint64_t rfne : 1; /**< RX FIFO Not Empty */ uint64_t tfe : 1; /**< TX FIFO Empty */ uint64_t tfnf : 1; /**< TX FIFO Not Full */ uint64_t busy : 1; /**< Busy bit (always 0 in PASS3) */ #else uint64_t busy : 1; uint64_t tfnf : 1; uint64_t tfe : 1; uint64_t rfne : 1; uint64_t rff : 1; uint64_t reserved_5_63 : 59; #endif } s; struct cvmx_mio_uart2_usr_s cn52xx; struct cvmx_mio_uart2_usr_s cn52xxp1; }; typedef union cvmx_mio_uart2_usr cvmx_mio_uart2_usr_t; #endif