mips: octeon: Add serdes and device helper support incl. DM PCIe driver
PATCH 41/50 mips: octeon: Add cvmx-pcie.c
In reply to Stefan RoeseFrom: Aaron Williams <[email protected]>
Import cvmx-pcie.c from 2013 U-Boot. It will be used by the later added drivers to support PCIe and networking on the MIPS Octeon II / III platforms.
---
arch/mips/mach-octeon/cvmx-pcie.c | 2487 +++++++++++++++++++++++++++++ 1 file changed, 2487 insertions(+) create mode 100644 arch/mips/mach-octeon/cvmx-pcie.c
arch/mips/mach-octeon/cvmx-pcie.c new file +2487 -0
@@ -0,0 +1,2487 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Marvell International Ltd. +* +* Interface to PCIe as a host(RC) or target(EP) +*/ + +#include <log.h> +#include <linux/delay.h> +#include <linux/libfdt.h> + +#include <mach/cvmx-regs.h> +#include <mach/octeon-model.h> +#include <mach/cvmx-fuse.h> +#include <mach/octeon-feature.h> +#include <mach/cvmx-qlm.h> +#include <mach/octeon_qlm.h> + +#include <mach/cvmx-helper-fdt.h> + +#include <mach/cvmx-regs.h> +#include <mach/octeon-model.h> +#include <mach/cvmx-fuse.h> +#include <mach/octeon-feature.h> +#include <mach/cvmx-qlm.h> +#include <mach/octeon_qlm.h> +#include <mach/cvmx-pcie.h> +#include <mach/cvmx-error.h> +#include <mach/cvmx-helper.h> +#include <mach/cvmx-helper-util.h> +#include <mach/cvmx-bgxx-defs.h> +#include <mach/cvmx-ciu-defs.h> +#include <mach/cvmx-gmxx-defs.h> +#include <mach/cvmx-gserx-defs.h> +#include <mach/cvmx-mio-defs.h> +#include <mach/cvmx-pciercx-defs.h> +#include <mach/cvmx-pcieepx-defs.h> +#include <mach/cvmx-pemx-defs.h> +#include <mach/cvmx-pexp-defs.h> +#include <mach/cvmx-rst-defs.h> +#include <mach/cvmx-sata-defs.h> +#include <mach/cvmx-sli-defs.h> +#include <mach/cvmx-sriomaintx-defs.h> +#include <mach/cvmx-sriox-defs.h> + +#include <mach/cvmx-dpi-defs.h> +#include <mach/cvmx-sli-defs.h> +#include <mach/cvmx-dtx-defs.h> + +DECLARE_GLOBAL_DATA_PTR ; + +#define MRRS_CN6XXX 3/* 1024 byte Max Read Request Size */ +#define MPS_CN6XXX 0/* 128 byte Max Packet Size (Limit of most PCs) */ + +/* Endian swap mode. */ +#define _CVMX_PCIE_ES 1 + +#define CVMX_READ_CSR (addr) csr_rd_node(node, addr) +#define CVMX_WRITE_CSR (addr, val) csr_wr_node(node, addr, val) +#define CVMX_PCIE_CFGX_READ (p, addr) cvmx_pcie_cfgx_read_node(node, p, addr) +#define CVMX_PCIE_CFGX_WRITE (p, addr, val) cvmx_pcie_cfgx_write_node(node, p, addr, val) + +/* #define DEBUG_PCIE */ + +/* Delay after link up, before issuing first configuration read */ +#define PCIE_DEVICE_READY_WAIT_DELAY_MICROSECONDS 700000 + +/* Recommended Preset Vector: Drop Preset 10 */ +int pcie_preset_vec[4 ] = {0x593 ,0x593 ,0x593 ,0x593 }; + +/* Number of LTSSM transitions to record, must be a power of 2 */ +#define LTSSM_HISTORY_SIZE 64 +#define MAX_RETRIES 2 + +bool pcie_link_initialized[CVMX_MAX_NODES ][CVMX_PCIE_MAX_PORTS ]; +int cvmx_primary_pcie_bus_number =1 ; + +static uint32_t __cvmx_pcie_config_read32 (int node,int pcie_port,int bus,int dev,int func, +int reg,int lst); + +/** +* Return the Core virtual base address for PCIe IO access. IOs are +* read/written as an offset from this address. +* +* @param pcie_port PCIe port the IO is for +* +* @return 64bit Octeon IO base address for read/write +*/ +uint64_t cvmx_pcie_get_io_base_address (int pcie_port) +{ +cvmx_pcie_address_t pcie_addr; + + pcie_addr.u64 =0 ; + pcie_addr.io.upper =0 ; + pcie_addr.io.io =1 ; + pcie_addr.io.did =3 ; + pcie_addr.io.subdid =2 ; + pcie_addr.io.node = (pcie_port >>4 ) &0x3 ; + pcie_addr.io.es = _CVMX_PCIE_ES; + pcie_addr.io.port = (pcie_port &0x3 ); +return pcie_addr.u64; +} + +/** +* Size of the IO address region returned at address +* cvmx_pcie_get_io_base_address() +* +* @param pcie_port PCIe port the IO is for +* +* @return Size of the IO window +*/ +uint64_t cvmx_pcie_get_io_size (int pcie_port) +{ +return 1ull <<32 ; +} + +/** +* Return the Core virtual base address for PCIe MEM access. Memory is +* read/written as an offset from this address. +* +* @param pcie_port PCIe port the IO is for +* +* @return 64bit Octeon IO base address for read/write +*/ +uint64_t cvmx_pcie_get_mem_base_address (int pcie_port) +{ +cvmx_pcie_address_t pcie_addr; + + pcie_addr.u64 =0 ; + pcie_addr.mem.upper =0 ; + pcie_addr.mem.io =1 ; + pcie_addr.mem.did =3 ; + pcie_addr.mem.subdid =3 + (pcie_port &0x3 ); + pcie_addr.mem.node = (pcie_port >>4 ) &0x3 ; +return pcie_addr.u64; +} + +/** +* Size of the Mem address region returned at address +* cvmx_pcie_get_mem_base_address() +* +* @param pcie_port PCIe port the IO is for +* +* @return Size of the Mem window +*/ +uint64_t cvmx_pcie_get_mem_size (int pcie_port) +{ +return 1ull <<36 ; +} + +/** +* @INTERNAL +* Return the QLM number for the PCIE port. +* +* @param pcie_port QLM number to return for. +* +* @return QLM number. +*/ +static int __cvmx_pcie_get_qlm (int node,int pcie_port) +{ +if (OCTEON_IS_MODEL (OCTEON_CN73XX )) { +cvmx_pemx_cfg_t pem_cfg; +cvmx_pemx_qlm_t pem_qlm; +cvmx_gserx_cfg_t gserx_cfg; + +switch (pcie_port) { +case 0 :/* PEM0 */ + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (0 )); +if (gserx_cfg.s.pcie) +return 0 ;/* PEM0 is on QLM0 and possibly QLM1 */ +else +return -1 ;/* PEM0 is disabled */ +case 1 :/* PEM1 */ + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (0 )); + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (1 )); +if (!pem_cfg.cn78xx.lanes8 && gserx_cfg.s.pcie) +return 1 ;/* PEM1 is on QLM 1 */ +else +return -1 ;/* PEM1 is disabled */ +case 2 :/* PEM2 */ + pem_qlm.u64 =CVMX_READ_CSR (CVMX_PEMX_QLM (2 )); +if (pem_qlm.cn73xx.pemdlmsel ==1 ) { + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (5 )); +if (gserx_cfg.s.pcie) +return 5 ;/* PEM2 is on DLM5 */ +else +return -1 ;/* PEM2 is disabled */ + } + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (2 )); +if (gserx_cfg.s.pcie) +return 2 ;/* PEM2 is on QLM2 and possibly QLM3 */ +else +return -1 ;/* PEM2 is disabled */ +case 3 :/* PEM3 */ + pem_qlm.u64 =CVMX_READ_CSR (CVMX_PEMX_QLM (3 )); +if (pem_qlm.cn73xx.pemdlmsel ==1 ) { + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (6 )); +if (gserx_cfg.s.pcie) +return 6 ;/* PEM2 is on DLM5 */ +else +return -1 ;/* PEM2 is disabled */ + } + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (2 )); + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (3 )); +if (!pem_cfg.cn78xx.lanes8 && gserx_cfg.s.pcie) +return 3 ;/* PEM2 is on QLM2 and possibly QLM3 */ +else +return -1 ;/* PEM2 is disabled */ +default : +printf ("Invalid %d PCIe port\n" , pcie_port); +return -2 ; + } + }else if (OCTEON_IS_MODEL (OCTEON_CN78XX )) { +cvmx_pemx_cfg_t pem_cfg; +cvmx_gserx_cfg_t gserx_cfg; + +switch (pcie_port) { +case 0 : + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (0 )); +if (gserx_cfg.s.pcie) +return 0 ;/* PEM0 is on QLM0 and possibly QLM1 */ +else +return -1 ;/* PEM0 is disabled */ +case 1 :/* PEM1 */ + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (0 )); + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (1 )); +if (!pem_cfg.cn78xx.lanes8 && gserx_cfg.s.pcie) +return 1 ;/* PEM1 is on QLM 1 */ +else +return -1 ;/* PEM1 is disabled */ +case 2 :/* PEM2 */ + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (2 )); +if (gserx_cfg.s.pcie) +return 2 ;/* PEM2 is on QLM2 and possibly QLM3 */ +else +return -1 ;/* PEM2 is disabled */ +case 3 :/* PEM3 */ + { +cvmx_gserx_cfg_t gser4_cfg; + + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (2 )); + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (3 )); + gser4_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (4 )); +if (pem_cfg.cn78xx.lanes8) { +if (gser4_cfg.s.pcie) +return 4 ;/* PEM3 is on QLM4 */ +else +return -1 ;/* PEM3 is disabled */ + }else { +if (gserx_cfg.s.pcie) +return 3 ;/* PEM3 is on QLM3 */ +else if (gser4_cfg.s.pcie) +return 4 ;/* PEM3 is on QLM4 */ +else +return -1 ;/* PEM3 is disabled */ + } + } +default : +printf ("Invalid %d PCIe port\n" , pcie_port); +return -1 ; + } + }else if (OCTEON_IS_MODEL (OCTEON_CN70XX )) { +enum cvmx_qlm_mode mode1 =cvmx_qlm_get_mode (1 ); +enum cvmx_qlm_mode mode2 =cvmx_qlm_get_mode (2 ); + +switch (pcie_port) { +case 0 :/* PCIe0 can be DLM1 with 1, 2 or 4 lanes */ +if (mode1 ==CVMX_QLM_MODE_PCIE ||/* Using DLM 1-2 */ + mode1 ==CVMX_QLM_MODE_PCIE_1X2 ||/* Using DLM 1 */ + mode1 ==CVMX_QLM_MODE_PCIE_2X1 ||/* Using DLM 1, lane 0 */ + mode1 ==CVMX_QLM_MODE_PCIE_1X1 )/* Using DLM 1, l0, l1 not used */ +return 1 ; +else +return -1 ; +case 1 :/* PCIe1 can be DLM1 1 lane(1), DLM2 1 lane(0) or 2 lanes(0-1) */ +if (mode1 ==CVMX_QLM_MODE_PCIE_2X1 ) +return 1 ; +else if (mode2 ==CVMX_QLM_MODE_PCIE_1X2 ) +return 2 ; +else if (mode2 ==CVMX_QLM_MODE_PCIE_2X1 ) +return 2 ; +else +return -1 ; +case 2 :/* PCIe2 can be DLM2 1 lanes(1) */ +if (mode2 ==CVMX_QLM_MODE_PCIE_2X1 ) +return 2 ; +else +return -1 ; +default :/* Only three PEM blocks */ +return -1 ; + } + }else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) { +cvmx_gserx_cfg_t gserx_cfg; + +switch (pcie_port) { +case 0 :/* PEM0 */ + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (0 )); +if (gserx_cfg.s.pcie) +return 0 ;/* PEM0 is on QLM0 and possibly QLM1 */ +else +return -1 ;/* PEM0 is disabled */ +case 1 :/* PEM1 */ + gserx_cfg.u64 =CVMX_READ_CSR (CVMX_GSERX_CFG (1 )); +if (gserx_cfg.s.pcie) +return 1 ;/* PEM1 is on DLM1 */ +else +return -1 ;/* PEM1 is disabled */ +default : +return -1 ; + } + } +return -1 ; +} + +/** +* @INTERNAL +* Initialize the RC config space CSRs +* +* @param node node +* @param pcie_port PCIe port to initialize +*/ +static void __cvmx_pcie_rc_initialize_config_space (int node,int pcie_port) +{ +/* Max Payload Size (PCIE*_CFG030[MPS]) */ +/* Max Read Request Size (PCIE*_CFG030[MRRS]) */ +/* Relaxed-order, no-snoop enables (PCIE*_CFG030[RO_EN,NS_EN] */ +/* Error Message Enables (PCIE*_CFG030[CE_EN,NFE_EN,FE_EN,UR_EN]) */ + { +cvmx_pciercx_cfg030_t pciercx_cfg030; + + pciercx_cfg030.u32 =CVMX_PCIE_CFGX_READ (pcie_port, +CVMX_PCIERCX_CFG030 (pcie_port)); + pciercx_cfg030.s.mps =MPS_CN6XXX ; + pciercx_cfg030.s.mrrs =MRRS_CN6XXX ; +/* +* Enable relaxed order processing. This will allow devices +* to affect read response ordering +*/ + pciercx_cfg030.s.ro_en =1 ; +/* Enable no snoop processing. Not used by Octeon */ + pciercx_cfg030.s.ns_en =1 ; +/* Correctable error reporting enable. */ + pciercx_cfg030.s.ce_en =1 ; +/* Non-fatal error reporting enable. */ + pciercx_cfg030.s.nfe_en =1 ; +/* Fatal error reporting enable. */ + pciercx_cfg030.s.fe_en =1 ; +/* Unsupported request reporting enable. */ + pciercx_cfg030.s.ur_en =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG030 (pcie_port), + pciercx_cfg030.u32); + } + +/* +* Max Payload Size (DPI_SLI_PRTX_CFG[MPS]) must match +* PCIE*_CFG030[MPS] +*/ +/* +* Max Read Request Size (DPI_SLI_PRTX_CFG[MRRS]) must not exceed +* PCIE*_CFG030[MRRS] +*/ +cvmx_dpi_sli_prtx_cfg_t prt_cfg; +cvmx_sli_s2m_portx_ctl_t sli_s2m_portx_ctl; + + prt_cfg.u64 =CVMX_READ_CSR (CVMX_DPI_SLI_PRTX_CFG (pcie_port)); + prt_cfg.s.mps =MPS_CN6XXX ; + prt_cfg.s.mrrs =MRRS_CN6XXX ; +/* Max outstanding load request. */ + prt_cfg.s.molr =32 ; +CVMX_WRITE_CSR (CVMX_DPI_SLI_PRTX_CFG (pcie_port), prt_cfg.u64); + + sli_s2m_portx_ctl.u64 =CVMX_READ_CSR (CVMX_PEXP_SLI_S2M_PORTX_CTL (pcie_port)); +if (!(OCTEON_IS_MODEL (OCTEON_CN78XX ) ||OCTEON_IS_MODEL (OCTEON_CN73XX ) || +OCTEON_IS_MODEL (OCTEON_CNF75XX ))) + sli_s2m_portx_ctl.cn61xx.mrrs =MRRS_CN6XXX ; +CVMX_WRITE_CSR (CVMX_PEXP_SLI_S2M_PORTX_CTL (pcie_port), sli_s2m_portx_ctl.u64); + +/* ECRC Generation (PCIE*_CFG070[GE,CE]) */ + { +cvmx_pciercx_cfg070_t pciercx_cfg070; + + pciercx_cfg070.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG070 (pcie_port)); + pciercx_cfg070.s.ge =1 ;/* ECRC generation enable. */ + pciercx_cfg070.s.ce =1 ;/* ECRC check enable. */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG070 (pcie_port), pciercx_cfg070.u32); + } + +/* Access Enables (PCIE*_CFG001[MSAE,ME]) */ +/* ME and MSAE should always be set. */ +/* Interrupt Disable (PCIE*_CFG001[I_DIS]) */ +/* System Error Message Enable (PCIE*_CFG001[SEE]) */ + { +cvmx_pciercx_cfg001_t pciercx_cfg001; + + pciercx_cfg001.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG001 (pcie_port)); + pciercx_cfg001.s.msae =1 ;/* Memory space enable. */ + pciercx_cfg001.s.me =1 ;/* Bus master enable. */ + pciercx_cfg001.s.i_dis =1 ;/* INTx assertion disable. */ + pciercx_cfg001.s.see =1 ;/* SERR# enable */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG001 (pcie_port), pciercx_cfg001.u32); + } + +/* Advanced Error Recovery Message Enables */ +/* (PCIE*_CFG066,PCIE*_CFG067,PCIE*_CFG069) */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG066 (pcie_port),0 ); +/* Use CVMX_PCIERCX_CFG067 hardware default */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG069 (pcie_port),0 ); + +/* Active State Power Management (PCIE*_CFG032[ASLPC]) */ + { +cvmx_pciercx_cfg032_t pciercx_cfg032; + + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG032 (pcie_port)); + pciercx_cfg032.s.aslpc =0 ;/* Active state Link PM control. */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG032 (pcie_port), pciercx_cfg032.u32); + } + +/* Link Width Mode (PCIERCn_CFG452[LME]) - Set during +* cvmx_pcie_rc_initialize_link() +*/ +/* Primary Bus Number (PCIERCn_CFG006[PBNUM]) */ + { +/* We set the primary bus number to 1 so IDT bridges are happy. +* They don't like zero +*/ +cvmx_pciercx_cfg006_t pciercx_cfg006; + + pciercx_cfg006.u32 =0 ; + pciercx_cfg006.s.pbnum = cvmx_primary_pcie_bus_number; + pciercx_cfg006.s.sbnum = cvmx_primary_pcie_bus_number; + pciercx_cfg006.s.subbnum = cvmx_primary_pcie_bus_number; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG006 (pcie_port), pciercx_cfg006.u32); + } + +/* Memory-mapped I/O BAR (PCIERCn_CFG008) */ +/* Most applications should disable the memory-mapped I/O BAR by */ +/* setting PCIERCn_CFG008[ML_ADDR] < PCIERCn_CFG008[MB_ADDR] */ + { +cvmx_pciercx_cfg008_t pciercx_cfg008; + + pciercx_cfg008.u32 =0 ; + pciercx_cfg008.s.mb_addr =0x100 ; + pciercx_cfg008.s.ml_addr =0 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG008 (pcie_port), pciercx_cfg008.u32); + } + +/* Prefetchable BAR (PCIERCn_CFG009,PCIERCn_CFG010,PCIERCn_CFG011) */ +/* Most applications should disable the prefetchable BAR by setting */ +/* PCIERCn_CFG011[UMEM_LIMIT],PCIERCn_CFG009[LMEM_LIMIT] < */ +/* PCIERCn_CFG010[UMEM_BASE],PCIERCn_CFG009[LMEM_BASE] */ + { +cvmx_pciercx_cfg009_t pciercx_cfg009; +cvmx_pciercx_cfg010_t pciercx_cfg010; +cvmx_pciercx_cfg011_t pciercx_cfg011; + + pciercx_cfg009.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG009 (pcie_port)); + pciercx_cfg010.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG010 (pcie_port)); + pciercx_cfg011.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG011 (pcie_port)); + pciercx_cfg009.s.lmem_base =0x100 ; + pciercx_cfg009.s.lmem_limit =0 ; + pciercx_cfg010.s.umem_base =0x100 ; + pciercx_cfg011.s.umem_limit =0 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG009 (pcie_port), pciercx_cfg009.u32); +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG010 (pcie_port), pciercx_cfg010.u32); +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG011 (pcie_port), pciercx_cfg011.u32); + } + +/* System Error Interrupt Enables (PCIERCn_CFG035[SECEE,SEFEE,SENFEE]) */ +/* PME Interrupt Enables (PCIERCn_CFG035[PMEIE]) */ + { +cvmx_pciercx_cfg035_t pciercx_cfg035; + + pciercx_cfg035.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG035 (pcie_port)); + pciercx_cfg035.s.secee =1 ;/* System error on correctable error enable. */ + pciercx_cfg035.s.sefee =1 ;/* System error on fatal error enable. */ + pciercx_cfg035.s.senfee =1 ;/* System error on non-fatal error enable. */ + pciercx_cfg035.s.pmeie =1 ;/* PME interrupt enable. */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG035 (pcie_port), pciercx_cfg035.u32); + } + +/* Advanced Error Recovery Interrupt Enables */ +/* (PCIERCn_CFG075[CERE,NFERE,FERE]) */ + { +cvmx_pciercx_cfg075_t pciercx_cfg075; + + pciercx_cfg075.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG075 (pcie_port)); + pciercx_cfg075.s.cere =1 ;/* Correctable error reporting enable. */ + pciercx_cfg075.s.nfere =1 ;/* Non-fatal error reporting enable. */ + pciercx_cfg075.s.fere =1 ;/* Fatal error reporting enable. */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG075 (pcie_port), pciercx_cfg075.u32); + } + +/* HP Interrupt Enables (PCIERCn_CFG034[HPINT_EN], */ +/* PCIERCn_CFG034[DLLS_EN,CCINT_EN]) */ + { +cvmx_pciercx_cfg034_t pciercx_cfg034; + + pciercx_cfg034.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG034 (pcie_port)); + pciercx_cfg034.s.hpint_en =1 ;/* Hot-plug interrupt enable. */ + pciercx_cfg034.s.dlls_en =1 ;/* Data Link Layer state changed enable */ + pciercx_cfg034.s.ccint_en =1 ;/* Command completed interrupt enable. */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG034 (pcie_port), pciercx_cfg034.u32); + } + +if (OCTEON_IS_MODEL (OCTEON_CN78XX ) ||OCTEON_IS_MODEL (OCTEON_CN73XX ) || +OCTEON_IS_MODEL (OCTEON_CNF75XX )) { +int qlm =__cvmx_pcie_get_qlm (node, pcie_port); +int speed =cvmx_qlm_get_gbaud_mhz (qlm); +cvmx_pemx_cfg_t pem_cfg; +cvmx_pciercx_cfg031_t cfg031; +cvmx_pciercx_cfg040_t cfg040; +cvmx_pciercx_cfg452_t cfg452; +cvmx_pciercx_cfg089_t cfg089; +cvmx_pciercx_cfg090_t cfg090; +cvmx_pciercx_cfg091_t cfg091; +cvmx_pciercx_cfg092_t cfg092; +cvmx_pciercx_cfg554_t cfg554; + +/* +* Make sure the PEM agrees with GSERX about the speed +* its going to try +*/ +switch (speed) { +case 2500 :/* Gen1 */ + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (pcie_port)); + pem_cfg.s.md =0 ; +CVMX_WRITE_CSR (CVMX_PEMX_CFG (pcie_port), pem_cfg.u64); + +/* Set the target link speed */ + cfg040.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG040 (pcie_port)); + cfg040.s.tls =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG040 (pcie_port), cfg040.u32); +break ; +case 5000 :/* Gen2 */ + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (pcie_port)); + pem_cfg.s.md =1 ; +CVMX_WRITE_CSR (CVMX_PEMX_CFG (pcie_port), pem_cfg.u64); + +/* Set the target link speed */ + cfg040.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG040 (pcie_port)); + cfg040.s.tls =2 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG040 (pcie_port), cfg040.u32); +break ; +case 8000 :/* Gen3 */ + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (pcie_port)); + pem_cfg.s.md =2 ; +CVMX_WRITE_CSR (CVMX_PEMX_CFG (pcie_port), pem_cfg.u64); + +/* Set the target link speed */ + cfg040.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG040 (pcie_port)); + cfg040.s.tls =3 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG040 (pcie_port), cfg040.u32); +break ; +default : +break ; + } + +/* Link Width Mode (PCIERCn_CFG452[LME]) */ + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (pcie_port)); + cfg452.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG452 (pcie_port)); +if (qlm >=5 ) + cfg452.s.lme =0x3 ; +else + cfg452.s.lme = (pem_cfg.cn78xx.lanes8) ?0xf :0x7 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG452 (pcie_port), cfg452.u32); + +/* Errata PEM-25990 - Disable ASLPMS */ + cfg031.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG031 (pcie_port)); + cfg031.s.aslpms =0 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG031 (pcie_port), cfg031.u32); + +/* CFG554.PRV default changed from 16'h7ff to 16'h593. */ + cfg554.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG554 (pcie_port)); + cfg554.s.prv = pcie_preset_vec[pcie_port]; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG554 (pcie_port), cfg554.u32); +/* Errata PEM-26189 - Disable the 2ms timer on all chips */ + cfg554.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG554 (pcie_port)); + cfg554.s.p23td =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG554 (pcie_port), cfg554.u32); + +/* Errata PEM-21178 - Change the CFG[089-092] LxUTP & LxDTP defaults. */ + cfg089.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG089 (pcie_port)); + cfg089.s.l1ddtp =7 ; + cfg089.s.l1utp =7 ; + cfg089.s.l0dtp =7 ; + cfg089.s.l0utp =7 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG089 (pcie_port), cfg089.u32); + cfg090.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG090 (pcie_port)); + cfg090.s.l3dtp =7 ; + cfg090.s.l3utp =7 ; + cfg090.s.l2dtp =7 ; + cfg090.s.l2utp =7 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG090 (pcie_port), cfg090.u32); + cfg091.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG091 (pcie_port)); + cfg091.s.l5dtp =7 ; + cfg091.s.l5utp =7 ; + cfg091.s.l4dtp =7 ; + cfg091.s.l4utp =7 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG091 (pcie_port), cfg091.u32); + cfg092.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG092 (pcie_port)); + cfg092.s.l7dtp =7 ; + cfg092.s.l7utp =7 ; + cfg092.s.l6dtp =7 ; + cfg092.s.l6utp =7 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG092 (pcie_port), cfg092.u32); + } +} + +static void __cvmx_increment_ba (cvmx_sli_mem_access_subidx_t *pmas) +{ +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) + pmas->cn68xx.ba++; +else + pmas->cn63xx.ba++; +} + +/* +* milliseconds to retry PCIe cfg-space access: +* Value 32(unscaled) was recommended in HRM, but may be too small for +* some PCIe devices. This 200mS default should cover most devices, +* but can be extended by bootparam cvmx-pcie.cfg_timeout, or reduced +* to speed boot if it is known that no devices need so much time. +*/ +static int cfg_timeout =200 ; + +static int cfg_retries (void ) +{ +static int cfg_ticks =-1 ; + +if (cfg_ticks <0 ) { +u64 nS = cfg_timeout *1000000 ; +const int ceiling =0xffff ; + + cfg_ticks = nS / (gd->bus_clk >>16 ); +if (cfg_ticks > ceiling) + cfg_ticks = ceiling; + } + +return cfg_ticks; +} + +/** +* @INTERNAL +* Enable/Disable PEMX_PEMON.pemon based on the direction. +* +* @param node node +* @param pcie_port PCIe port +* @param direction 0 to disable, 1 to enable +*/ +static void __cvmx_pcie_config_pemon (int node,int pcie_port,bool direction) +{ +cvmx_pemx_on_t pemon; + + pemon.u64 =CVMX_READ_CSR (CVMX_PEMX_ON (pcie_port)); + pemon.s.pemon = direction; +CVMX_WRITE_CSR (CVMX_PEMX_ON (pcie_port), pemon.u64); + pemon.u64 =CVMX_READ_CSR (CVMX_PEMX_ON (pcie_port)); +} + +/** +* @INTERNAL +* De-assert GSER_PHY.phy_reset for a given qlm +* +* @param node node +* @param qlm qlm for a given PCIe port +*/ +static void __cvmx_pcie_gser_phy_config (int node,int pcie_port,int qlm) +{ +cvmx_pemx_cfg_t pem_cfg; +cvmx_gserx_phy_ctl_t ctrl; +int has_8lanes =0 ; +int is_gen3 =0 ; + + ctrl.u64 =CVMX_READ_CSR (CVMX_GSERX_PHY_CTL (qlm)); + +/* Assert the reset */ + ctrl.s.phy_reset =1 ; +CVMX_WRITE_CSR (CVMX_GSERX_PHY_CTL (qlm), ctrl.u64); + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (pcie_port)); +udelay (10 ); + + has_8lanes = pem_cfg.cn78xx.lanes8; + is_gen3 = pem_cfg.cn78xx.md >=2 ; + +if (has_8lanes) { + ctrl.u64 =CVMX_READ_CSR (CVMX_GSERX_PHY_CTL (qlm +1 )); + ctrl.s.phy_reset =1 ; +CVMX_WRITE_CSR (CVMX_GSERX_PHY_CTL (qlm +1 ), ctrl.u64); + ctrl.u64 =CVMX_READ_CSR (CVMX_GSERX_PHY_CTL (qlm +1 )); + } + ctrl.u64 =CVMX_READ_CSR (CVMX_GSERX_PHY_CTL (qlm)); +udelay (10 ); + +/* Deassert the reset */ + ctrl.s.phy_reset =0 ; +CVMX_WRITE_CSR (CVMX_GSERX_PHY_CTL (qlm), ctrl.u64); + pem_cfg.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG (pcie_port)); +udelay (500 ); + +if (has_8lanes) { + ctrl.u64 =CVMX_READ_CSR (CVMX_GSERX_PHY_CTL (qlm +1 )); + ctrl.s.phy_reset =0 ; +CVMX_WRITE_CSR (CVMX_GSERX_PHY_CTL (qlm +1 ), ctrl.u64); + } + ctrl.u64 =CVMX_READ_CSR (CVMX_GSERX_PHY_CTL (qlm)); +udelay (500 ); + +/* Apply some erratas after PHY reset, only applies to PCIe GEN3 */ +if (is_gen3) { +int i; +int high_qlm = has_8lanes ? qlm +1 : qlm; + +/* Apply workaround for Errata GSER-26150 */ +if (OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_0 )) { +for (i = qlm; i < high_qlm; i++) { +cvmx_gserx_glbl_pll_cfg_3_t pll_cfg_3; +cvmx_gserx_glbl_misc_config_1_t misc_config_1; +/* Update PLL parameters */ +/* +* Step 1: Set +* GSER()_GLBL_PLL_CFG_3[PLL_VCTRL_SEL_LCVCO_VAL] = 0x2, +* and +* GSER()_GLBL_PLL_CFG_3[PCS_SDS_PLL_VCO_AMP] = 0 +*/ + pll_cfg_3.u64 =CVMX_READ_CSR (CVMX_GSERX_GLBL_PLL_CFG_3 (i)); + pll_cfg_3.s.pcs_sds_pll_vco_amp =0 ; + pll_cfg_3.s.pll_vctrl_sel_lcvco_val =2 ; +CVMX_WRITE_CSR (CVMX_GSERX_GLBL_PLL_CFG_3 (i), pll_cfg_3.u64); + +/* +* Step 2: Set +* GSER()_GLBL_MISC_CONFIG_1[PCS_SDS_TRIM_CHP_REG] = 0x2. +*/ + misc_config_1.u64 =CVMX_READ_CSR (CVMX_GSERX_GLBL_MISC_CONFIG_1 (i)); + misc_config_1.s.pcs_sds_trim_chp_reg =2 ; +CVMX_WRITE_CSR (CVMX_GSERX_GLBL_MISC_CONFIG_1 (i), misc_config_1.u64); + } + } + +/* Apply workaround for Errata GSER-25992 */ +if (OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_X ) || +OCTEON_IS_MODEL (OCTEON_CN78XX_PASS1_X )) { +for (i = qlm; i < high_qlm; i++) +cvmx_qlm_gser_errata_25992 (node, i); + } + } +} + +/* Get the PCIe LTSSM state for the given port +* +* @param node Node to query +* @param pcie_port PEM to query +* +* @return LTSSM state +*/ +static int __cvmx_pcie_rc_get_ltssm_state (int node,int pcie_port) +{ +u64 debug; + +if (OCTEON_IS_MODEL (OCTEON_CN73XX ) && pcie_port ==0 ) { +CVMX_WRITE_CSR (CVMX_DTX_SPEM_SELX (0 ),0 ); +CVMX_READ_CSR (CVMX_DTX_SPEM_SELX (0 )); +CVMX_WRITE_CSR (CVMX_DTX_SPEM_ENAX (0 ),0xfffffffffull ); +CVMX_READ_CSR (CVMX_DTX_SPEM_ENAX (0 )); + +/* Read the value */ + debug =CVMX_READ_CSR (CVMX_DTX_SPEM_DATX (0 )); + +/* Disable the PEM from driving OCLA signals */ +CVMX_WRITE_CSR (CVMX_DTX_SPEM_ENAX (0 ),0 ); +CVMX_READ_CSR (CVMX_DTX_SPEM_ENAX (0 )); + }else { +/* LTSSM state is in debug select 0 */ +CVMX_WRITE_CSR (CVMX_DTX_PEMX_SELX (0 , pcie_port),0 ); +CVMX_READ_CSR (CVMX_DTX_PEMX_SELX (0 , pcie_port)); +CVMX_WRITE_CSR (CVMX_DTX_PEMX_ENAX (0 , pcie_port),0xfffffffffull ); +CVMX_READ_CSR (CVMX_DTX_PEMX_ENAX (0 , pcie_port)); + +/* Read the value */ + debug =CVMX_READ_CSR (CVMX_DTX_PEMX_DATX (0 , pcie_port)); + +/* Disable the PEM from driving OCLA signals */ +CVMX_WRITE_CSR (CVMX_DTX_PEMX_ENAX (0 , pcie_port),0 ); +CVMX_READ_CSR (CVMX_DTX_PEMX_ENAX (0 , pcie_port)); + } + +/* DBGSEL = 0x0, bits[8:3] */ +return cvmx_bit_extract (debug,3 ,6 ); +} + +/** +* Get the PCIe LTSSM state for the given port +* +* @param node Node to query +* @param pcie_port PEM to query +* +* @return LTSSM state +*/ +static const char *cvmx_pcie_get_ltssm_string (int ltssm) +{ +switch (ltssm) { +case 0x00 : +return "DETECT_QUIET" ; +case 0x01 : +return "DETECT_ACT" ; +case 0x02 : +return "POLL_ACTIVE" ; +case 0x03 : +return "POLL_COMPLIANCE" ; +case 0x04 : +return "POLL_CONFIG" ; +case 0x05 : +return "PRE_DETECT_QUIET" ; +case 0x06 : +return "DETECT_WAIT" ; +case 0x07 : +return "CFG_LINKWD_START" ; +case 0x08 : +return "CFG_LINKWD_ACEPT" ; +case 0x09 : +return "CFG_LANENUM_WAIT" ; +case 0x0A : +return "CFG_LANENUM_ACEPT" ; +case 0x0B : +return "CFG_COMPLETE" ; +case 0x0C : +return "CFG_IDLE" ; +case 0x0D : +return "RCVRY_LOCK" ; +case 0x0E : +return "RCVRY_SPEED" ; +case 0x0F : +return "RCVRY_RCVRCFG" ; +case 0x10 : +return "RCVRY_IDLE" ; +case 0x11 : +return "L0" ; +case 0x12 : +return "L0S" ; +case 0x13 : +return "L123_SEND_EIDLE" ; +case 0x14 : +return "L1_IDLE" ; +case 0x15 : +return "L2_IDLE" ; +case 0x16 : +return "L2_WAKE" ; +case 0x17 : +return "DISABLED_ENTRY" ; +case 0x18 : +return "DISABLED_IDLE" ; +case 0x19 : +return "DISABLED" ; +case 0x1A : +return "LPBK_ENTRY" ; +case 0x1B : +return "LPBK_ACTIVE" ; +case 0x1C : +return "LPBK_EXIT" ; +case 0x1D : +return "LPBK_EXIT_TIMEOUT" ; +case 0x1E : +return "HOT_RESET_ENTRY" ; +case 0x1F : +return "HOT_RESET" ; +case 0x20 : +return "RCVRY_EQ0" ; +case 0x21 : +return "RCVRY_EQ1" ; +case 0x22 : +return "RCVRY_EQ2" ; +case 0x23 : +return "RCVRY_EQ3" ; +default : +return "Unknown" ; + } +} + +/** +* During PCIe link initialization we need to make config request to the attached +* device to verify its speed and width. These config access happen very early +* after the device is taken out of reset, so may fail for some amount of time. +* This function automatically retries these config accesses. The normal builtin +* hardware retry isn't enough for this very early access. +* +* @param node Note to read from +* @param pcie_port PCIe port to read from +* @param bus PCIe bus number +* @param dev PCIe device +* @param func PCIe function on the device +* @param reg Register to read +* +* @return Config register value, or all ones on failure +*/ +static uint32_t cvmx_pcie_config_read32_retry (int node,int pcie_port,int bus,int dev,int func, +int reg) +{ +/* +* Read the PCI config register until we get a valid value. Some cards +* require time after link up to return data. Wait@most 3 seconds +*/ +u64 timeout =300 ; +u32 val; + +do { +/* Read PCI capability pointer */ + val =__cvmx_pcie_config_read32 (node, pcie_port, bus, dev, func, reg,0 ); + +/* Check the read succeeded */ +if (val !=0xffffffff ) +return val; +/* Failed, wait a little and try again */ +mdelay (10 ); + }while (--timeout); + +debug ("N%d.PCIe%d: Config read failed, can't communicate with device\n" , + node, pcie_port); + +return -1 ; +} + +/** +* @INTERNAL +* Initialize a host mode PCIe gen 2 link. This function takes a PCIe +* port from reset to a link up state. Software can then begin +* configuring the rest of the link. +* +* @param node node +* @param pcie_port PCIe port to initialize +* +* @return Zero on success +*/ +static int __cvmx_pcie_rc_initialize_link_gen2 (int node,int pcie_port) +{ +u64 start_cycle; + +cvmx_pemx_ctl_status_t pem_ctl_status; +cvmx_pciercx_cfg032_t pciercx_cfg032; +cvmx_pciercx_cfg448_t pciercx_cfg448; + +if (OCTEON_IS_OCTEON3 ()) { +if (CVMX_WAIT_FOR_FIELD64_NODE (node,CVMX_PEMX_ON (pcie_port), cvmx_pemx_on_t, + pemoor, ==, 1, 100000)) { +printf ("%d:PCIe: Port %d PEM not on, skipping\n" , node, pcie_port); +return -1 ; + } + } + +/* Bring up the link */ + pem_ctl_status.u64 =CVMX_READ_CSR (CVMX_PEMX_CTL_STATUS (pcie_port)); + pem_ctl_status.s.lnk_enb =1 ; +CVMX_WRITE_CSR (CVMX_PEMX_CTL_STATUS (pcie_port), pem_ctl_status.u64); + +/* Wait for the link to come up */ + start_cycle =get_timer (0 ); +do { +if (get_timer (start_cycle) >1000 ) +return -1 ; + +udelay (1000 ); + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ (pcie_port, +CVMX_PCIERCX_CFG032 (pcie_port)); + }while ((pciercx_cfg032.s.dlla ==0 ) || (pciercx_cfg032.s.lt ==1 )); + +/* Update the Replay Time Limit. Empirically, some PCIe devices take a +* little longer to respond than expected under load. As a workaround +* for this we configure the Replay Time Limit to the value expected +* for a 512 byte MPS instead of our actual 256 byte MPS. The numbers +* below are directly from the PCIe spec table 3-4 +*/ + pciercx_cfg448.u32 =CVMX_PCIE_CFGX_READ (pcie_port, +CVMX_PCIERCX_CFG448 (pcie_port)); +switch (pciercx_cfg032.s.nlw) { +case 1 :/* 1 lane */ + pciercx_cfg448.s.rtl =1677 ; +break ; +case 2 :/* 2 lanes */ + pciercx_cfg448.s.rtl =867 ; +break ; +case 4 :/* 4 lanes */ + pciercx_cfg448.s.rtl =462 ; +break ; +case 8 :/* 8 lanes */ + pciercx_cfg448.s.rtl =258 ; +break ; + } +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG448 (pcie_port), + pciercx_cfg448.u32); + +return 0 ; +} + +extern int octeon_pcie_get_qlm_from_fdt (int numa_node,int pcie_port); + +static int __cvmx_pcie_check_pcie_port (int node,int pcie_port,enum cvmx_qlm_mode mode) +{ +if (mode ==CVMX_QLM_MODE_SRIO_1X4 || mode ==CVMX_QLM_MODE_SRIO_2X2 || + mode ==CVMX_QLM_MODE_SRIO_4X1 ) { +printf ("%d:PCIe: Port %d is SRIO, skipping.\n" , node, pcie_port); +return -1 ; + }else if (mode ==CVMX_QLM_MODE_SGMII ) { +printf ("%d:PCIe: Port %d is SGMII, skipping.\n" , node, pcie_port); +return -1 ; + }else if (mode ==CVMX_QLM_MODE_XAUI || mode ==CVMX_QLM_MODE_RXAUI ) { +printf ("%d:PCIe: Port %d is XAUI, skipping.\n" , node, pcie_port); +return -1 ; + }else if (mode ==CVMX_QLM_MODE_ILK ) { +printf ("%d:PCIe: Port %d is ILK, skipping.\n" , node, pcie_port); +return -1 ; + }else if (mode !=CVMX_QLM_MODE_PCIE && + mode !=CVMX_QLM_MODE_PCIE_1X8 && + mode !=CVMX_QLM_MODE_PCIE_1X2 && + mode !=CVMX_QLM_MODE_PCIE_2X1 && + mode !=CVMX_QLM_MODE_PCIE_1X1 ) { +printf ("%d:PCIe: Port %d is unknown, skipping.\n" , + node, pcie_port); +return -1 ; + } +return 0 ; +} + +static int __cvmx_pcie_check_qlm_mode (int node,int pcie_port,int qlm) +{ +enum cvmx_qlm_mode mode =CVMX_QLM_MODE_DISABLED ; + +if (qlm <0 ) +return -1 ; + +/* Make sure this interface is PCIe */ +if (OCTEON_IS_MODEL (OCTEON_CN70XX )) { +if (cvmx_qlm_get_dlm_mode (1 , pcie_port) == +CVMX_QLM_MODE_DISABLED ) { +printf ("PCIe: Port %d not in PCIe mode, skipping\n" , + pcie_port); +return -1 ; + } + }else if (octeon_has_feature (OCTEON_FEATURE_PCIE )) { +/* +* Requires reading the MIO_QLMX_CFG register to figure +* out the port type. +*/ +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) { + qlm =3 - (pcie_port *2 ); + }else if (OCTEON_IS_MODEL (OCTEON_CN61XX )) { +cvmx_mio_qlmx_cfg_t qlm_cfg; + + qlm_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (1 )); +if (qlm_cfg.s.qlm_cfg ==1 ) + qlm =1 ; +else + qlm = pcie_port; + }else if (OCTEON_IS_MODEL (OCTEON_CN66XX ) || +OCTEON_IS_MODEL (OCTEON_CN63XX )) { + qlm = pcie_port; + } + +/* +* PCIe is allowed only in QLM1, 1 PCIe port in x2 or +* 2 PCIe ports in x1 +*/ +else if (OCTEON_IS_MODEL (OCTEON_CNF71XX )) + qlm =1 ; + + mode =cvmx_qlm_get_mode (qlm); + +__cvmx_pcie_check_pcie_port (node, pcie_port, mode); + } +return 0 ; +} + +static void __cvmx_pcie_sli_config (int node,int pcie_port) +{ +cvmx_pemx_bar_ctl_t pemx_bar_ctl; +cvmx_pemx_ctl_status_t pemx_ctl_status; +cvmx_sli_ctl_portx_t sli_ctl_portx; +cvmx_sli_mem_access_ctl_t sli_mem_access_ctl; +cvmx_sli_mem_access_subidx_t mem_access_subid; +cvmx_pemx_bar1_indexx_t bar1_index; +int i; + +/* Store merge control (SLI_MEM_ACCESS_CTL[TIMER,MAX_WORD]) */ + sli_mem_access_ctl.u64 =CVMX_READ_CSR (CVMX_PEXP_SLI_MEM_ACCESS_CTL ); + sli_mem_access_ctl.s.max_word =0 ;/* Allow 16 words to combine */ + sli_mem_access_ctl.s.timer =127 ;/* Wait up to 127 cycles for more data */ +CVMX_WRITE_CSR (CVMX_PEXP_SLI_MEM_ACCESS_CTL , sli_mem_access_ctl.u64); + +/* Setup Mem access SubDIDs */ + mem_access_subid.u64 =0 ; + mem_access_subid.s.port = pcie_port;/* Port the request is sent to. */ + mem_access_subid.s.nmerge =0 ;/* Allow merging as it works on CN6XXX. */ + mem_access_subid.s.esr = _CVMX_PCIE_ES;/* Endian-swap for Reads. */ + mem_access_subid.s.esw = _CVMX_PCIE_ES;/* Endian-swap for Writes. */ + mem_access_subid.s.wtype =0 ;/* "No snoop" and "Relaxed ordering" are not set */ + mem_access_subid.s.rtype =0 ;/* "No snoop" and "Relaxed ordering" are not set */ +/* PCIe Address Bits <63:34>. */ +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) + mem_access_subid.cn68xx.ba =0 ; +else + mem_access_subid.cn63xx.ba =0 ; + +/* Setup mem access 12-15 for port 0, 16-19 for port 1, supplying 36 +* bits of address space +*/ +for (i =12 + pcie_port *4 ; i <16 + pcie_port *4 ; i++) { +CVMX_WRITE_CSR (CVMX_PEXP_SLI_MEM_ACCESS_SUBIDX (i), mem_access_subid.u64); +/* Set each SUBID to extend the addressable range */ +__cvmx_increment_ba (&mem_access_subid); + } + +if (OCTEON_IS_MODEL (OCTEON_CN63XX ) ||OCTEON_IS_MODEL (OCTEON_CN66XX ) || +OCTEON_IS_MODEL (OCTEON_CN68XX ) || + (OCTEON_IS_OCTEON3 () && !OCTEON_IS_MODEL (OCTEON_CN70XX ))) { +/* Disable the peer to peer forwarding register. This must be +* setup by the OS after it enumerates the bus and assigns +* addresses to the PCIe busses +*/ +for (i =0 ; i <4 ; i++) { +CVMX_WRITE_CSR (CVMX_PEMX_P2P_BARX_START (i, pcie_port),-1 ); +CVMX_WRITE_CSR (CVMX_PEMX_P2P_BARX_END (i, pcie_port),-1 ); + } + } + +/* Set Octeon's BAR0 to decode 0-16KB. It overlaps with Bar2 */ +CVMX_WRITE_CSR (CVMX_PEMX_P2N_BAR0_START (pcie_port),0 ); + +/* Set Octeon's BAR2 to decode 0-2^41. Bar0 and Bar1 take precedence +* where they overlap. It also overlaps with the device addresses, so +* make sure the peer to peer forwarding is set right +*/ +CVMX_WRITE_CSR (CVMX_PEMX_P2N_BAR2_START (pcie_port),0 ); + +/* Setup BAR2 attributes */ +/* Relaxed Ordering (NPEI_CTL_PORTn[PTLP_RO,CTLP_RO, WAIT_COM]) */ +/* - PTLP_RO,CTLP_RO should normally be set (except for debug). */ +/* - WAIT_COM=0 will likely work for all applications. */ +/* Load completion relaxed ordering (NPEI_CTL_PORTn[WAITL_COM]) */ + pemx_bar_ctl.u64 =CVMX_READ_CSR (CVMX_PEMX_BAR_CTL (pcie_port)); + pemx_bar_ctl.s.bar1_siz =3 ;/* 256MB BAR1 */ + pemx_bar_ctl.s.bar2_enb =1 ; + pemx_bar_ctl.s.bar2_esx = _CVMX_PCIE_ES; + pemx_bar_ctl.s.bar2_cax =0 ; +CVMX_WRITE_CSR (CVMX_PEMX_BAR_CTL (pcie_port), pemx_bar_ctl.u64); + sli_ctl_portx.u64 =CVMX_READ_CSR (CVMX_PEXP_SLI_CTL_PORTX (pcie_port)); + sli_ctl_portx.s.ptlp_ro =1 ; + sli_ctl_portx.s.ctlp_ro =1 ; + sli_ctl_portx.s.wait_com =0 ; + sli_ctl_portx.s.waitl_com =0 ; +CVMX_WRITE_CSR (CVMX_PEXP_SLI_CTL_PORTX (pcie_port), sli_ctl_portx.u64); + +/* BAR1 follows BAR2 */ +CVMX_WRITE_CSR (CVMX_PEMX_P2N_BAR1_START (pcie_port), +CVMX_PCIE_BAR1_RC_BASE ); + + bar1_index.u64 =0 ; + bar1_index.s.addr_idx = (CVMX_PCIE_BAR1_PHYS_BASE >>22 ); + bar1_index.s.ca =1 ;/* Not Cached */ + bar1_index.s.end_swp = _CVMX_PCIE_ES;/* Endian Swap mode */ + bar1_index.s.addr_v =1 ;/* Valid entry */ + +for (i =0 ; i <16 ; i++) { +CVMX_WRITE_CSR (CVMX_PEMX_BAR1_INDEXX (i, pcie_port), + bar1_index.u64); +/* 256MB / 16 >> 22 == 4 */ + bar1_index.s.addr_idx += (((1ull <<28 ) /16ull ) >>22 ); + } + +/* Wait for 200ms */ + pemx_ctl_status.u64 =CVMX_READ_CSR (CVMX_PEMX_CTL_STATUS (pcie_port)); + pemx_ctl_status.cn63xx.cfg_rtry =cfg_retries (); +CVMX_WRITE_CSR (CVMX_PEMX_CTL_STATUS (pcie_port), pemx_ctl_status.u64); + +/* +* Here is the second part of the config retry changes. Wait for 700ms +* after setting up the link before continuing. PCIe says the devices +* may need up to 900ms to come up. 700ms plus 200ms from above gives +* us a total of 900ms +*/ +if (OCTEON_IS_OCTEON2 () ||OCTEON_IS_MODEL (OCTEON_CN70XX )) +udelay (PCIE_DEVICE_READY_WAIT_DELAY_MICROSECONDS ); +} + +/** +* Initialize a PCIe gen 2 port for use in host(RC) mode. It doesn't enumerate +* the bus. +* +* @param pcie_port PCIe port to initialize +* +* @return Zero on success +*/ +static int __cvmx_pcie_rc_initialize_gen2 (int pcie_port) +{ +cvmx_ciu_soft_prst_t ciu_soft_prst; +cvmx_mio_rst_ctlx_t mio_rst_ctl; +cvmx_pemx_bist_status_t pemx_bist_status; +cvmx_pemx_bist_status2_t pemx_bist_status2; +cvmx_pciercx_cfg032_t pciercx_cfg032; +cvmx_pciercx_cfg515_t pciercx_cfg515; +u64 ciu_soft_prst_reg, rst_ctl_reg; +int ep_mode; +int qlm =0 ; +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; + +if (pcie_port >=CVMX_PCIE_PORTS ) { +//debug("Invalid PCIe%d port\n", pcie_port); +return -1 ; + } + +if (__cvmx_pcie_check_qlm_mode (node, pcie_port, qlm)) +return -1 ; + +/* Make sure we aren't trying to setup a target mode interface in host +* mode +*/ +if (OCTEON_IS_OCTEON3 ()) { + ciu_soft_prst_reg =CVMX_RST_SOFT_PRSTX (pcie_port); + rst_ctl_reg =CVMX_RST_CTLX (pcie_port); + }else { + ciu_soft_prst_reg = (pcie_port) ?CVMX_CIU_SOFT_PRST1 :CVMX_CIU_SOFT_PRST ; + rst_ctl_reg =CVMX_MIO_RST_CTLX (pcie_port); + } + mio_rst_ctl.u64 =CVMX_READ_CSR (rst_ctl_reg); + + ep_mode = ((OCTEON_IS_MODEL (OCTEON_CN61XX ) ||OCTEON_IS_MODEL (OCTEON_CNF71XX )) ? + (mio_rst_ctl.s.prtmode !=1 ) : + (!mio_rst_ctl.s.host_mode)); + +if (OCTEON_IS_MODEL (OCTEON_CN70XX ) && pcie_port) { +cvmx_pemx_cfg_t pemx_cfg; + + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (0 )); +if ((pemx_cfg.s.md &3 ) ==2 ) { +printf ("PCIe: Port %d in 1x4 mode.\n" , pcie_port); +return -1 ; + } + } + +if (ep_mode) { +printf ("%d:PCIe: Port %d in endpoint mode.\n" , node, pcie_port); +return -1 ; + } + +/* CN63XX Pass 1.0 errata G-14395 requires the QLM De-emphasis be +* programmed +*/ +if (OCTEON_IS_MODEL (OCTEON_CN63XX_PASS1_0 )) { +if (pcie_port) { +cvmx_ciu_qlm1_t ciu_qlm; + + ciu_qlm.u64 =csr_rd (CVMX_CIU_QLM1 ); + ciu_qlm.s.txbypass =1 ; + ciu_qlm.s.txdeemph =5 ; + ciu_qlm.s.txmargin =0x17 ; +csr_wr (CVMX_CIU_QLM1 , ciu_qlm.u64); + }else { +cvmx_ciu_qlm0_t ciu_qlm; + + ciu_qlm.u64 =csr_rd (CVMX_CIU_QLM0 ); + ciu_qlm.s.txbypass =1 ; + ciu_qlm.s.txdeemph =5 ; + ciu_qlm.s.txmargin =0x17 ; +csr_wr (CVMX_CIU_QLM0 , ciu_qlm.u64); + } + } + +/* Bring the PCIe out of reset */ + ciu_soft_prst.u64 =CVMX_READ_CSR (ciu_soft_prst_reg); +/* After a chip reset the PCIe will also be in reset. If it +* isn't, most likely someone is trying to init it again +* without a proper PCIe reset. +*/ +if (ciu_soft_prst.s.soft_prst ==0 ) { +/* Reset the port */ + ciu_soft_prst.s.soft_prst =1 ; +CVMX_WRITE_CSR (ciu_soft_prst_reg, ciu_soft_prst.u64); + +/* Read to make sure write happens */ + ciu_soft_prst.u64 =CVMX_READ_CSR (ciu_soft_prst_reg); + +/* Keep PERST asserted for 2 ms */ +udelay (2000 ); + } + +/* Deassert PERST */ + ciu_soft_prst.u64 =CVMX_READ_CSR (ciu_soft_prst_reg); + ciu_soft_prst.s.soft_prst =0 ; +CVMX_WRITE_CSR (ciu_soft_prst_reg, ciu_soft_prst.u64); + ciu_soft_prst.u64 =CVMX_READ_CSR (ciu_soft_prst_reg); + +/* Wait 1ms for PCIe reset to complete */ +udelay (1000 ); + +/* Set MPLL multiplier as per Errata 20669. */ +if (OCTEON_IS_MODEL (OCTEON_CN70XX )) { +int qlm =__cvmx_pcie_get_qlm (0 , pcie_port); +enum cvmx_qlm_mode mode; +int old_mult; +u64 meas_refclock =cvmx_qlm_measure_clock (qlm); + +if (meas_refclock >99000000 && meas_refclock <101000000 ) { + old_mult =35 ; + }else if (meas_refclock >124000000 && + meas_refclock <126000000 ) { + old_mult =56 ; + }else if (meas_refclock >156000000 && + meas_refclock <156500000 ) { + old_mult =45 ; + }else { +printf ("%s: Invalid reference clock for qlm %d\n" , + __func__, qlm); +return -1 ; + } + mode =cvmx_qlm_get_mode (qlm); +__cvmx_qlm_set_mult (qlm,2500 , old_mult); +/* Adjust mplls for both dlms when configured as pcie 1x4 */ +if (mode ==CVMX_QLM_MODE_PCIE && pcie_port ==0 ) +__cvmx_qlm_set_mult (qlm +1 ,2500 , old_mult); + } + +/* +* Check and make sure PCIe came out of reset. If it doesn't the board +* probably hasn't wired the clocks up and the interface should be +* skipped +*/ +if (CVMX_WAIT_FOR_FIELD64_NODE (node, rst_ctl_reg, cvmx_mio_rst_ctlx_t, + rst_done, ==, 1, 10000)) { +printf ("%d:PCIe: Port %d stuck in reset, skipping.\n" , node, pcie_port); +return -1 ; + } + +/* Check BIST status */ + pemx_bist_status.u64 =CVMX_READ_CSR (CVMX_PEMX_BIST_STATUS (pcie_port)); +if (pemx_bist_status.u64) +printf ("%d:PCIe: BIST FAILED for port %d (0x%016llx)\n" , node, pcie_port, +CAST64 (pemx_bist_status.u64)); + pemx_bist_status2.u64 =CVMX_READ_CSR (CVMX_PEMX_BIST_STATUS2 (pcie_port)); + +/* +* Errata PCIE-14766 may cause the lower 6 bits to be randomly set on +* CN63XXp1 +*/ +if (OCTEON_IS_MODEL (OCTEON_CN63XX_PASS1_X )) + pemx_bist_status2.u64 &= ~0x3full ; + +if (pemx_bist_status2.u64) { +printf ("%d:PCIe: BIST2 FAILED for port %d (0x%016llx)\n" , + node, pcie_port,CAST64 (pemx_bist_status2.u64)); + } + +/* Initialize the config space CSRs */ +__cvmx_pcie_rc_initialize_config_space (node, pcie_port); + +/* Enable gen2 speed selection */ + pciercx_cfg515.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG515 (pcie_port)); + pciercx_cfg515.s.dsc =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG515 (pcie_port), pciercx_cfg515.u32); + +/* Bring the link up */ +if (__cvmx_pcie_rc_initialize_link_gen2 (node, pcie_port)) { +/* Some gen1 devices don't handle the gen 2 training correctly. +* Disable gen2 and try again with only gen1 +*/ +cvmx_pciercx_cfg031_t pciercx_cfg031; + + pciercx_cfg031.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG031 (pcie_port)); + pciercx_cfg031.s.mls =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG031 (pcie_port), pciercx_cfg031.u32); +if (__cvmx_pcie_rc_initialize_link_gen2 (node, pcie_port)) { +printf ("PCIe: Link timeout on port %d, probably the slot is empty\n" , + pcie_port); +return -1 ; + } + } + +__cvmx_pcie_sli_config (node, pcie_port); + +/* Display the link status */ + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG032 (pcie_port)); +printf ("PCIe: Port %d link active, %d lanes, speed gen%d\n" , pcie_port, + pciercx_cfg032.s.nlw, pciercx_cfg032.s.ls); + + pcie_link_initialized[node][pcie_port] = true; +return 0 ; +} + +/** +* @INTERNAL +* Initialize a host mode PCIe gen 2 link. This function takes a PCIe +* port from reset to a link up state. Software can then begin +* configuring the rest of the link. +* +* @param node node +* @param pcie_port PCIe port to initialize +* +* @return Zero on success +*/ +static int __cvmx_pcie_rc_initialize_link_gen2_v3 (int node,int pcie_port) +{ +u8 ltssm_history[LTSSM_HISTORY_SIZE ]; +int ltssm_history_loc; +cvmx_pemx_ctl_status_t pem_ctl_status; +cvmx_pciercx_cfg006_t pciercx_cfg006; +cvmx_pciercx_cfg031_t pciercx_cfg031; +cvmx_pciercx_cfg032_t pciercx_cfg032; +cvmx_pciercx_cfg068_t pciercx_cfg068; +cvmx_pciercx_cfg448_t pciercx_cfg448; +cvmx_pciercx_cfg515_t pciercx_cfg515; +int max_gen, max_width; +u64 hold_time; +u64 bounce_allow_time; +u64 timeout, good_time, current_time; +int neg_gen, neg_width, bus, dev_gen, dev_width; +unsigned int cap, cap_next; +int ltssm_state, desired_gen; +int desired_width; +int i, need_speed_change, need_lane_change; +int do_retry_speed =0 ; +int link_up =0 , is_loop_done =0 ; + + if (CVMX_WAIT_FOR_FIELD64_NODE(node, CVMX_PEMX_ON(pcie_port), cvmx_pemx_on_t, pemoor, ==, 1, +100000 )) { +printf ("N%d:PCIe: Port %d PEM not on, skipping\n" , node, pcie_port); +return -1 ; + } + +/* Record starting LTSSM state for debug */ +memset (ltssm_history,-1 ,sizeof (ltssm_history)); + ltssm_history[0 ] =__cvmx_pcie_rc_get_ltssm_state (node, pcie_port); + ltssm_history_loc =0 ; + + pciercx_cfg031.u32 =CVMX_PCIE_CFGX_READ (pcie_port, +CVMX_PCIERCX_CFG031 (pcie_port)); +/* Max speed of PEM from config (1-3) */ + max_gen = pciercx_cfg031.s.mls; +/* Max lane width of PEM (1-3) */ + max_width = pciercx_cfg031.s.mlw; +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link supports up to %d lanes, speed gen%d\n" , + node, pcie_port, max_width, max_gen); +#endif + +/* Bring up the link */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Enabling the link\n" , node, pcie_port); +#endif + pem_ctl_status.u64 =CVMX_READ_CSR (CVMX_PEMX_CTL_STATUS (pcie_port)); + pem_ctl_status.s.lnk_enb =1 ; +CVMX_WRITE_CSR (CVMX_PEMX_CTL_STATUS (pcie_port), pem_ctl_status.u64); + +/* +* Configure SLI after enabling PCIe link. Is required for reading +* PCIe card capabilities. +*/ +__cvmx_pcie_sli_config (node, pcie_port); + +/* +* After the link is enabled no prints until link up or error, +* Otherwise will miss link state captures +*/ + +retry_speed: +/* Clear RC Correctable Error Status Register */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG068 (pcie_port),-1 ); + +/* Wait for the link to come up and link training to be complete */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Waiting for link\n" , node, pcie_port); +#endif + +/* Timeout of 2 secs */ + timeout =get_timer (0 ) +2000 ; + +/* Records when the link first went good */ + good_time =0 ; + +do { + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG032 (pcie_port)); +/* +* Errata PEM-31375 PEM RSL access to PCLK registers can +* timeout during speed change. Check for temporary hardware +* timeout, and rety if happens +*/ +if (pciercx_cfg032.u32 ==0xffffffff ) +continue ; + +/* Record LTSSM state for debug */ + ltssm_state =__cvmx_pcie_rc_get_ltssm_state (node, pcie_port); + +if (ltssm_history[ltssm_history_loc] != ltssm_state) { + ltssm_history_loc = (ltssm_history_loc +1 ) & (LTSSM_HISTORY_SIZE -1 ); + ltssm_history[ltssm_history_loc] = ltssm_state; + } + +/* Check if the link is up */ +// current_time = cvmx_get_cycle(); + current_time =get_timer (0 ); + link_up = (pciercx_cfg032.s.dlla && !pciercx_cfg032.s.lt); + +if (link_up) { +/* Is this the first link up? */ +if (!good_time) { +/* Mark the time when the link transitioned to good */ + good_time = current_time; + }else { +/* Check for a link error */ + pciercx_cfg068.u32 =CVMX_PCIE_CFGX_READ ( + pcie_port,CVMX_PCIERCX_CFG068 (pcie_port)); +if (pciercx_cfg068.s.res) { +/* +* Ignore errors before we've been +* stable for bounce_allow_time +*/ +if (good_time + bounce_allow_time <= + current_time) { +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link errors after link up\n" , + node, pcie_port); +#endif +/* Link error, signal a retry */ +return 1 ; + } + +/* +* Clear RC Correctable Error +* Status Register +*/ +CVMX_PCIE_CFGX_WRITE (pcie_port, +CVMX_PCIERCX_CFG068 (pcie_port), +-1 ); +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Ignored error during settling time\n" , + node, pcie_port); +#endif + } + } + }else if (good_time) { +if (good_time + bounce_allow_time <= current_time) { +/* +* We allow bounces for bounce_allow_time after +* the link is good. Once this time passes any +* bounce requires a retry +*/ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link bounce detected\n" , + node, pcie_port); +#endif +return 1 ;/* Link bounce, signal a retry */ + } + +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Ignored bounce during settling time\n" , + node, pcie_port); +#endif + } + +/* Determine if we've hit the timeout */ + is_loop_done = (current_time >= timeout); + +/* +* Determine if we've had a good link for the required hold +* time +*/ + is_loop_done |= link_up && (good_time + hold_time <= + current_time); + }while (!is_loop_done); + +/* Trace the LTSSM state */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: LTSSM History\n" , node, pcie_port); +#endif +for (i =0 ; i <LTSSM_HISTORY_SIZE ; i++) { + ltssm_history_loc = (ltssm_history_loc +1 ) & (LTSSM_HISTORY_SIZE -1 ); +#ifdef DEBUG_PCIE +if (ltssm_history[ltssm_history_loc] !=0xff ) +printf ("N%d.PCIe%d: %s\n" , node, pcie_port, +cvmx_pcie_get_ltssm_string (ltssm_history[ltssm_history_loc])); +#endif + } + +if (!link_up) { + ltssm_state =__cvmx_pcie_rc_get_ltssm_state (node, pcie_port); +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link down, Data link layer %s(DLLA=%d), Link training %s(LT=%d), LTSSM %s\n" , + node, pcie_port, pciercx_cfg032.s.dlla ?"active" :"down" , + pciercx_cfg032.s.dlla, pciercx_cfg032.s.lt ?"active" :"complete" , + pciercx_cfg032.s.lt,cvmx_pcie_get_ltssm_string (ltssm_state)); +#endif +return 1 ;/* Link down, signal a retry */ + } + +/* Report the negotiated link speed and width */ + neg_gen = pciercx_cfg032.s.ls;/* Current speed of PEM (1-3) */ + neg_width = pciercx_cfg032.s.nlw;/* Current lane width of PEM (1-8) */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link negotiated %d lanes, speed gen%d\n" , node, pcie_port, neg_width, + neg_gen); +#endif +/* Determine PCIe bus number the directly attached device uses */ + pciercx_cfg006.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG006 (pcie_port)); + bus = pciercx_cfg006.s.sbnum; + +/* The SLI has to be initialized so we can read the downstream devices */ + dev_gen =1 ;/* Device max speed (1-3) */ + dev_width =1 ;/* Device max lane width (1-16) */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Reading Bus %d device max speed and width\n" , node, pcie_port, bus); +#endif + +/* +* Here is the second part of the config retry changes. Wait for 700ms +* after setting up the link before continuing. PCIe says the devices +* may need up to 900ms to come up. 700ms plus 200ms from above gives +* us a total of 900ms +*/ +udelay (PCIE_DEVICE_READY_WAIT_DELAY_MICROSECONDS ); + +/* Read PCI capability pointer at offset 0x34 of target */ + cap =cvmx_pcie_config_read32_retry (node, pcie_port, bus,0 ,0 ,0x34 ); + +/* Check if we were able to read capabilities pointer */ +if (cap ==0xffffffff ) +return 1 ;/* Signal retry needed */ + +/* Read device max speed and width */ + cap_next = cap &0xff ; +while (cap_next) { + cap =cvmx_pcie_config_read32_retry (node, pcie_port, bus, +0 ,0 , cap_next); +if (cap ==0xffffffff ) +return 1 ;/* Signal retry needed */ + +/* Is this a PCIe capability (0x10)? */ +if ((cap &0xff ) ==0x10 ) { +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Found PCIe capability@offset 0x%x\n" , + node, pcie_port, cap_next); +#endif +/* Offset 0xc contains the max link info */ + cap =cvmx_pcie_config_read32_retry (node, pcie_port, bus,0 ,0 , + cap_next +0xc ); +if (cap ==0xffffffff ) +return 1 ;/* Signal retry needed */ + dev_gen = cap &0xf ;/* Max speed of PEM from config (1-3) */ + dev_width = (cap >>4 ) &0x3f ;/* Max lane width of PEM (1-16) */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Device supports %d lanes, speed gen%d\n" , node, + pcie_port, dev_width, dev_gen); +#endif +break ; + } +/* Move to next capability */ + cap_next = (cap >>8 ) &0xff ; + } + +/* +* Desired link speed and width is either limited by the device or our +* PEM configuration. Choose the most restrictive limit +*/ + desired_gen = (dev_gen < max_gen) ? dev_gen : max_gen; + desired_width = (dev_width < max_width) ? dev_width : max_width; + +/* +* We need a change if we don't match the desired speed or width. +* Note that we allow better than expected in case the device lied +* about its capabilities +*/ + need_speed_change = (neg_gen < desired_gen); + need_lane_change = (neg_width < desired_width); + +if (need_lane_change) { +/* We didn't get the maximum number of lanes */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link width (%d) less that supported (%d)\n" , + node, pcie_port, neg_width, desired_width); +#endif +return 2 ;/* Link wrong width, signal a retry */ + }else if (need_speed_change) { +if (do_retry_speed) { +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link speed (gen%d) less that supported (gen%d)\n" , node, + pcie_port, neg_gen, desired_gen); +#endif +return 1 ;/* Link at width, but speed low. Request a retry */ + } + +/* We didn't get the maximum speed. Request a speed change */ +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link speed (gen%d) less that supported (gen%d), requesting a speed change\n" , + node, pcie_port, neg_gen, desired_gen); +#endif + pciercx_cfg515.u32 = +CVMX_PCIE_CFGX_READ (pcie_port, +CVMX_PCIERCX_CFG515 (pcie_port)); + pciercx_cfg515.s.dsc =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port, +CVMX_PCIERCX_CFG515 (pcie_port), + pciercx_cfg515.u32); +mdelay (100 ); + do_retry_speed = true; + goto retry_speed; + }else { +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link at best speed and width\n" , + node, pcie_port); +#endif +/* For gen3 links check if we are getting errors over the link */ +if (neg_gen ==3 ) { +/* Read RC Correctable Error Status Register */ + pciercx_cfg068.u32 = +CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG068 (pcie_port)); +if (pciercx_cfg068.s.res) { +#ifdef DEBUG_PCIE +printf ("N%d.PCIe%d: Link reporting error status\n" , node, + pcie_port); +#endif +return 1 ;/* Getting receiver errors, request a retry */ + } + } +return 0 ;/* Link@correct speed and width */ + } + +/* Update the Replay Time Limit. Empirically, some PCIe devices take a +* little longer to respond than expected under load. As a workaround +* for this we configure the Replay Time Limit to the value expected +* for a 512 byte MPS instead of our actual 256 byte MPS. The numbers +* below are directly from the PCIe spec table 3-4 +*/ + pciercx_cfg448.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG448 (pcie_port)); +switch (pciercx_cfg032.s.nlw) { +case 1 :/* 1 lane */ + pciercx_cfg448.s.rtl =1677 ; +break ; +case 2 :/* 2 lanes */ + pciercx_cfg448.s.rtl =867 ; +break ; +case 4 :/* 4 lanes */ + pciercx_cfg448.s.rtl =462 ; +break ; +case 8 :/* 8 lanes */ + pciercx_cfg448.s.rtl =258 ; +break ; + } +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG448 (pcie_port), pciercx_cfg448.u32); + +return 0 ; +} + +static int __cvmx_pcie_rc_initialize_gen2_v3 (int pcie_port) +{ +cvmx_rst_ctlx_t rst_ctl; +cvmx_rst_soft_prstx_t rst_soft_prst; +cvmx_pciercx_cfg031_t pciercx_cfg031; +cvmx_pciercx_cfg032_t pciercx_cfg032; +cvmx_pciercx_cfg038_t pciercx_cfg038; +cvmx_pciercx_cfg040_t pciercx_cfg040; +cvmx_pciercx_cfg515_t pciercx_cfg515; +cvmx_pciercx_cfg548_t pciercx_cfg548; +cvmx_pemx_bist_status_t pemx_bist_status; +u64 rst_soft_prst_reg; +int qlm; +int node = (pcie_port >>4 ) &0x3 ; +bool requires_pem_reset =0 ; +enum cvmx_qlm_mode mode =CVMX_QLM_MODE_DISABLED ; +int retry_count =0 ; +int result =0 ; + + pcie_port &=0x3 ; + +/* Assume link down until proven up */ + pcie_link_initialized[node][pcie_port] = false; + +/* Attempt link initialization up to 3 times */ +while (retry_count <=MAX_RETRIES ) { +#ifdef DEBUG_PCIE +if (retry_count) +printf ("N%d:PCIE%d: Starting link retry %d\n" , node, pcie_port, + retry_count); +#endif +if (pcie_port >=CVMX_PCIE_PORTS ) { +#ifdef DEBUG_PCIE +printf ("Invalid PCIe%d port\n" , pcie_port); +#endif +return -1 ; + } + + qlm =__cvmx_pcie_get_qlm (node, pcie_port); + +if (qlm <0 ) +return -1 ; + + mode =cvmx_qlm_get_mode (qlm); +if (__cvmx_pcie_check_pcie_port (node, pcie_port, mode)) +return -1 ; + + rst_soft_prst_reg =CVMX_RST_SOFT_PRSTX (pcie_port); + rst_ctl.u64 =CVMX_READ_CSR (CVMX_RST_CTLX (pcie_port)); + +if (OCTEON_IS_MODEL (OCTEON_CN78XX )) { +CVMX_WRITE_CSR (CVMX_DTX_PEMX_SELX (0 , pcie_port),0x17 ); +CVMX_WRITE_CSR (CVMX_DTX_PEMX_SELX (1 , pcie_port),0 ); + } + +if (!rst_ctl.s.host_mode) { +printf ("N%d:PCIE: Port %d in endpoint mode.\n" , + node, pcie_port); +return -1 ; + } + +/* Bring the PCIe out of reset */ + rst_soft_prst.u64 =CVMX_READ_CSR (rst_soft_prst_reg); + +/* +* After a chip reset the PCIe will also be in reset. If it +* isn't, most likely someone is trying to init it again +* without a proper PCIe reset. +*/ +if (rst_soft_prst.s.soft_prst ==0 ) { +/* Disable the MAC controller before resetting */ +__cvmx_pcie_config_pemon (node, pcie_port,0 ); + +/* Reset the port */ + rst_soft_prst.s.soft_prst =1 ; +CVMX_WRITE_CSR (rst_soft_prst_reg, rst_soft_prst.u64); + +/* Read to make sure write happens */ + rst_soft_prst.u64 =CVMX_READ_CSR (rst_soft_prst_reg); + +/* Keep PERST asserted for 2 ms */ +udelay (2000 ); + +/* Reset GSER_PHY to put in a clean state */ +__cvmx_pcie_gser_phy_config (node, pcie_port, qlm); + requires_pem_reset =1 ; + +/* Enable MAC controller before taking pcie out of reset */ +__cvmx_pcie_config_pemon (node, pcie_port,1 ); + } + +/* Deassert PERST */ + rst_soft_prst.u64 =CVMX_READ_CSR (rst_soft_prst_reg); + rst_soft_prst.s.soft_prst =0 ; +CVMX_WRITE_CSR (rst_soft_prst_reg, rst_soft_prst.u64); + rst_soft_prst.u64 =CVMX_READ_CSR (rst_soft_prst_reg); + +/* Check if PLLs are locked after GSER_PHY reset. */ +if (requires_pem_reset) { +cvmx_pemx_cfg_t pemx_cfg; + + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (pcie_port)); +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_QLM_STAT (qlm), cvmx_gserx_qlm_stat_t, + rst_rdy, ==, 1, 10000)) { +printf ("QLM%d: Timeout waiting for GSERX_QLM_STAT[rst_rdy]\n" , qlm); +return -1 ; + } +if (pemx_cfg.cn78xx.lanes8 && + (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_QLM_STAT (qlm +1 ), + cvmx_gserx_qlm_stat_t, rst_rdy, ==, 1, 10000))) { +printf ("QLM%d: Timeout waiting for GSERX_QLM_STAT[rst_rdy]\n" , + qlm +1 ); +return -1 ; + } + } + +/* Wait 1ms for PCIe reset to complete */ +udelay (1000 ); + +/* +* Check and make sure PCIe came out of reset. If it doesn't +* the board probably hasn't wired the clocks up and the +* interface should be skipped +*/ +if (CVMX_WAIT_FOR_FIELD64_NODE (node,CVMX_RST_CTLX (pcie_port), + cvmx_rst_ctlx_t, + rst_done, ==, 1, 10000)) { +printf ("N%d:PCIE: Port %d stuck in reset, skipping.\n" , node, pcie_port); +return -1 ; + } + +/* Check BIST status */ + pemx_bist_status.u64 =CVMX_READ_CSR (CVMX_PEMX_BIST_STATUS (pcie_port)); +if (pemx_bist_status.u64) +printf ("N%d:PCIE: BIST FAILED for port %d (0x%016llx)\n" , node, pcie_port, +CAST64 (pemx_bist_status.u64)); + +/* Initialize the config space CSRs */ +#ifdef DEBUG_PCIE +printf ("N%d:PCIE%d Initialize Config Space\n" , node, pcie_port); +#endif +__cvmx_pcie_rc_initialize_config_space (node, pcie_port); + +/* Enable gen2 speed selection */ + pciercx_cfg515.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG515 (pcie_port)); + pciercx_cfg515.s.dsc =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG515 (pcie_port), pciercx_cfg515.u32); + +/* Do the link retries on the PCIe interface */ +if (retry_count ==MAX_RETRIES ) { +/* +* This has to be done AFTER the QLM/PHY interface +* initialized +*/ + pciercx_cfg031.u32 = +CVMX_PCIE_CFGX_READ (pcie_port, +CVMX_PCIERCX_CFG031 (pcie_port)); +/* +* Drop speed to gen2 if link bouncing +* Result = -1 PEM in reset +* Result = 0: link speed and width ok no retry needed +* Result = 1: link errors or speed change needed +* Result = 2: lane width error +*/ +if (pciercx_cfg031.s.mls ==3 && result !=2 ) { +#ifdef DEBUG_PCIE +printf ("N%d:PCIE%d: Dropping speed to gen2\n" , node, pcie_port); +#endif + pciercx_cfg031.s.mls =2 ; +CVMX_PCIE_CFGX_WRITE (pcie_port, +CVMX_PCIERCX_CFG031 (pcie_port), + pciercx_cfg031.u32); + +/* Set the target link speed */ + pciercx_cfg040.u32 =CVMX_PCIE_CFGX_READ ( + pcie_port,CVMX_PCIERCX_CFG040 (pcie_port)); + pciercx_cfg040.s.tls =2 ; +CVMX_PCIE_CFGX_WRITE (pcie_port, +CVMX_PCIERCX_CFG040 (pcie_port), + pciercx_cfg040.u32); + } + } + +/* Bring the link up */ + result =__cvmx_pcie_rc_initialize_link_gen2_v3 (node, pcie_port); +if (result ==0 ) { +#ifdef DEBUG_PCIE +printf ("N%d:PCIE%d: Link does not need a retry\n" , node, pcie_port); +#endif +break ; + }else if (result >0 ) { +if (retry_count >=MAX_RETRIES ) { +int link_up; +#ifdef DEBUG_PCIE +printf ("N%d:PCIE%d: Link requested a retry, but hit the max retries\n" , + node, pcie_port); +#endif +/* If the link is down, report failure */ + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ ( + pcie_port, +CVMX_PCIERCX_CFG032 (pcie_port)); + link_up = (pciercx_cfg032.s.dlla && !pciercx_cfg032.s.lt); +if (!link_up) + result =-1 ; + } +#ifdef DEBUG_PCIE + else + printf("N%d.PCIE%d: Link requested a retry\n", node, pcie_port); +#endif + } +if (result <0 ) { +int ltssm_state =__cvmx_pcie_rc_get_ltssm_state (node, pcie_port); + +printf ("N%d:PCIE%d: Link timeout, probably the slot is empty (LTSSM %s)\n" , + node, pcie_port,cvmx_pcie_get_ltssm_string (ltssm_state)); +return -1 ; + } + retry_count++; + } + + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG032 (pcie_port)); +/* +* Errata PEM-28816: Link retrain initiated@GEN1 can cause PCIE +* link to hang. For Gen1 links we must disable equalization +*/ +if (pciercx_cfg032.s.ls ==1 ) { +#ifdef DEBUG_PCIE +printf ("N%d:PCIE%d: Disabling equalization for GEN1 Link\n" , node, pcie_port); +#endif + pciercx_cfg548.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG548 (pcie_port)); + pciercx_cfg548.s.ed =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG548 (pcie_port), pciercx_cfg548.u32); + } + +/* Errata PCIE-29440: Atomic operations to work properly */ + pciercx_cfg038.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG038 (pcie_port)); + pciercx_cfg038.s.atom_op_eb =0 ; + pciercx_cfg038.s.atom_op =1 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG038 (pcie_port), pciercx_cfg038.u32); + +/* Errata PCIE-29566 PEM Link Hangs after going into L1 */ + pciercx_cfg548.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG548 (pcie_port)); + pciercx_cfg548.s.grizdnc =0 ; +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIERCX_CFG548 (pcie_port), pciercx_cfg548.u32); + +if (result <0 ) +return result; + +/* Display the link status */ + pciercx_cfg032.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIERCX_CFG032 (pcie_port)); +printf ("N%d:PCIe: Port %d link active, %d lanes, speed gen%d\n" , node, pcie_port, + pciercx_cfg032.s.nlw, pciercx_cfg032.s.ls); + + pcie_link_initialized[node][pcie_port] = true; +return 0 ; +} + +/** +* Initialize a PCIe port for use in host(RC) mode. It doesn't enumerate the bus. +* +* @param pcie_port PCIe port to initialize for a node +* +* @return Zero on success +*/ +int cvmx_pcie_rc_initialize (int pcie_port) +{ +int result; + +if (OCTEON_IS_OCTEON2 () ||OCTEON_IS_MODEL (OCTEON_CN70XX )) + result =__cvmx_pcie_rc_initialize_gen2 (pcie_port); +else + result =__cvmx_pcie_rc_initialize_gen2_v3 (pcie_port); + +if (result ==0 ) +cvmx_error_enable_group (CVMX_ERROR_GROUP_PCI , pcie_port); +return result; +} + +/** +* Shutdown a PCIe port and put it in reset +* +* @param pcie_port PCIe port to shutdown for a node +* +* @return Zero on success +*/ +int cvmx_pcie_rc_shutdown (int pcie_port) +{ +u64 ciu_soft_prst_reg; +cvmx_ciu_soft_prst_t ciu_soft_prst; +int node; + +/* Shutdown only if PEM is in RC mode */ +if (!cvmx_pcie_is_host_mode (pcie_port)) +return -1 ; + + node = (pcie_port >>4 ) &0x3 ; + pcie_port &=0x3 ; +cvmx_error_disable_group (CVMX_ERROR_GROUP_PCI , pcie_port); +/* Wait for all pending operations to complete */ +if (CVMX_WAIT_FOR_FIELD64_NODE (node,CVMX_PEMX_CPL_LUT_VALID (pcie_port), + cvmx_pemx_cpl_lut_valid_t, tag, ==, +0 ,2000 )) +debug ("PCIe: Port %d shutdown timeout\n" , pcie_port); + +if (OCTEON_IS_OCTEON3 ()) { + ciu_soft_prst_reg =CVMX_RST_SOFT_PRSTX (pcie_port); + }else { + ciu_soft_prst_reg = (pcie_port) ?CVMX_CIU_SOFT_PRST1 : +CVMX_CIU_SOFT_PRST ; + } + +/* Force reset */ + ciu_soft_prst.u64 =CVMX_READ_CSR (ciu_soft_prst_reg); + ciu_soft_prst.s.soft_prst =1 ; +CVMX_WRITE_CSR (ciu_soft_prst_reg, ciu_soft_prst.u64); + +return 0 ; +} + +/** +* @INTERNAL +* Build a PCIe config space request address for a device +* +* @param node node +* @param port PCIe port (relative to the node) to access +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* +* @return 64bit Octeon IO address +*/ +static uint64_t __cvmx_pcie_build_config_addr (int node,int port,int bus,int dev,int fn,int reg) +{ +cvmx_pcie_address_t pcie_addr; +cvmx_pciercx_cfg006_t pciercx_cfg006; + + pciercx_cfg006.u32 =cvmx_pcie_cfgx_read_node (node, port, +CVMX_PCIERCX_CFG006 (port)); +if (bus <= pciercx_cfg006.s.pbnum && dev !=0 ) +return 0 ; + + pcie_addr.u64 =0 ; + pcie_addr.config.upper =2 ; + pcie_addr.config.io =1 ; + pcie_addr.config.did =3 ; + pcie_addr.config.subdid =1 ; + pcie_addr.config.node = node; + pcie_addr.config.es = _CVMX_PCIE_ES; + pcie_addr.config.port = port; +/* Always use config type 0 */ +if (pciercx_cfg006.s.pbnum ==0 ) + pcie_addr.config.ty = (bus > pciercx_cfg006.s.pbnum +1 ); +else + pcie_addr.config.ty = (bus > pciercx_cfg006.s.pbnum); + pcie_addr.config.bus = bus; + pcie_addr.config.dev = dev; + pcie_addr.config.func = fn; + pcie_addr.config.reg = reg; +return pcie_addr.u64; +} + +/** +* Read 8bits from a Device's config space +* +* @param pcie_port PCIe port the device is on +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* +* @return Result of the read +*/ +uint8_t cvmx_pcie_config_read8 (int pcie_port,int bus,int dev,int fn,int reg) +{ +u64 address; +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; + address =__cvmx_pcie_build_config_addr (node, pcie_port, bus, dev, fn, reg); +if (address) +return cvmx_read64_uint8 (address); +else +return 0xff ; +} + +/** +* Read 16bits from a Device's config space +* +* @param pcie_port PCIe port the device is on +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* +* @return Result of the read +*/ +uint16_t cvmx_pcie_config_read16 (int pcie_port,int bus,int dev,int fn,int reg) +{ +u64 address; +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; + address =__cvmx_pcie_build_config_addr (node, pcie_port, bus, dev, fn, reg); +if (address) +return le16_to_cpu (cvmx_read64_uint16 (address)); +else +return 0xffff ; +} + +static uint32_t __cvmx_pcie_config_read32 (int node,int pcie_port,int bus,int dev,int func, +int reg,int lst) +{ +u64 address; + + address =__cvmx_pcie_build_config_addr (node, pcie_port, bus, dev, func, reg); +if (lst) { +if (address && pcie_link_initialized[node][pcie_port]) +return le32_to_cpu (cvmx_read64_uint32 (address)); +else +return 0xffffffff ; + }else if (address) { +return le32_to_cpu (cvmx_read64_uint32 (address)); + }else { +return 0xffffffff ; + } +} + +/** +* Read 32bits from a Device's config space +* +* @param pcie_port PCIe port the device is on +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* +* @return Result of the read +*/ +uint32_t cvmx_pcie_config_read32 (int pcie_port,int bus,int dev,int fn,int reg) +{ +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; +return __cvmx_pcie_config_read32 (node, pcie_port, bus, dev, fn, reg, + pcie_link_initialized[node][pcie_port]); +} + +/** +* Write 8bits to a Device's config space +* +* @param pcie_port PCIe port the device is on +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* @param val Value to write +*/ +void cvmx_pcie_config_write8 (int pcie_port,int bus,int dev,int fn,int reg,uint8_t val) +{ +u64 address; +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; + address =__cvmx_pcie_build_config_addr (node, pcie_port, bus, dev, fn, reg); +if (address) +cvmx_write64_uint8 (address, val); +} + +/** +* Write 16bits to a Device's config space +* +* @param pcie_port PCIe port the device is on +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* @param val Value to write +*/ +void cvmx_pcie_config_write16 (int pcie_port,int bus,int dev,int fn,int reg,uint16_t val) +{ +u64 address; +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; + address =__cvmx_pcie_build_config_addr (node, pcie_port, bus, dev, fn, reg); +if (address) +cvmx_write64_uint16 (address,cpu_to_le16 (val)); +} + +/** +* Write 32bits to a Device's config space +* +* @param pcie_port PCIe port the device is on +* @param bus Sub bus +* @param dev Device ID +* @param fn Device sub function +* @param reg Register to access +* @param val Value to write +*/ +void cvmx_pcie_config_write32 (int pcie_port,int bus,int dev,int fn,int reg,uint32_t val) +{ +u64 address; +int node = (pcie_port >>4 ) &0x3 ; + + pcie_port &=0x3 ; + address =__cvmx_pcie_build_config_addr (node, pcie_port, bus, dev, fn, reg); +if (address) +cvmx_write64_uint32 (address,cpu_to_le32 (val)); +} + +/** +* Read a PCIe config space register indirectly. This is used for +* registers of the form PCIEEP_CFG??? and PCIERC?_CFG???. +* +* @param pcie_port PCIe port to read from +* @param cfg_offset Address to read +* +* @return Value read +*/ +uint32_t cvmx_pcie_cfgx_read (int pcie_port,uint32_t cfg_offset) +{ +return cvmx_pcie_cfgx_read_node (0 , pcie_port, cfg_offset); +} + +uint32_t cvmx_pcie_cfgx_read_node (int node,int pcie_port,uint32_t cfg_offset) +{ +cvmx_pemx_cfg_rd_t pemx_cfg_rd; + + pemx_cfg_rd.u64 =0 ; + pemx_cfg_rd.s.addr = cfg_offset; +CVMX_WRITE_CSR (CVMX_PEMX_CFG_RD (pcie_port), pemx_cfg_rd.u64); + pemx_cfg_rd.u64 =CVMX_READ_CSR (CVMX_PEMX_CFG_RD (pcie_port)); + +return pemx_cfg_rd.s.data; +} + +/** +* Write a PCIe config space register indirectly. This is used for +* registers of the form PCIEEP_CFG??? and PCIERC?_CFG???. +* +* @param pcie_port PCIe port to write to +* @param cfg_offset Address to write +* @param val Value to write +*/ +void cvmx_pcie_cfgx_write (int pcie_port,uint32_t cfg_offset,uint32_t val) +{ +cvmx_pcie_cfgx_write_node (0 , pcie_port, cfg_offset, val); +} + +void cvmx_pcie_cfgx_write_node (int node,int pcie_port,uint32_t cfg_offset,uint32_t val) +{ +cvmx_pemx_cfg_wr_t pemx_cfg_wr; + + pemx_cfg_wr.u64 =0 ; + pemx_cfg_wr.s.addr = cfg_offset; + pemx_cfg_wr.s.data = val; +CVMX_WRITE_CSR (CVMX_PEMX_CFG_WR (pcie_port), pemx_cfg_wr.u64); +} + +extern int cvmx_pcie_is_host_mode (int pcie_port); + +/** +* Initialize a PCIe port for use in target(EP) mode. +* +* @param pcie_port PCIe port to initialize for a node +* +* @return Zero on success +*/ +int cvmx_pcie_ep_initialize (int pcie_port) +{ +int node = (pcie_port >>4 ) &0x3 ; + +if (cvmx_pcie_is_host_mode (pcie_port)) +return -1 ; + + pcie_port &=0x3 ; + +/* CN63XX Pass 1.0 errata G-14395 requires the QLM De-emphasis be +* programmed +*/ +if (OCTEON_IS_MODEL (OCTEON_CN63XX_PASS1_0 )) { +if (pcie_port) { +cvmx_ciu_qlm1_t ciu_qlm; + + ciu_qlm.u64 =csr_rd (CVMX_CIU_QLM1 ); + ciu_qlm.s.txbypass =1 ; + ciu_qlm.s.txdeemph =5 ; + ciu_qlm.s.txmargin =0x17 ; +csr_wr (CVMX_CIU_QLM1 , ciu_qlm.u64); + }else { +cvmx_ciu_qlm0_t ciu_qlm; + + ciu_qlm.u64 =csr_rd (CVMX_CIU_QLM0 ); + ciu_qlm.s.txbypass =1 ; + ciu_qlm.s.txdeemph =5 ; + ciu_qlm.s.txmargin =0x17 ; +csr_wr (CVMX_CIU_QLM0 , ciu_qlm.u64); + } + } + +/* Enable bus master and memory */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIEEPX_CFG001 (pcie_port),0x6 ); + +/* Max Payload Size (PCIE*_CFG030[MPS]) */ +/* Max Read Request Size (PCIE*_CFG030[MRRS]) */ +/* Relaxed-order, no-snoop enables (PCIE*_CFG030[RO_EN,NS_EN] */ +/* Error Message Enables (PCIE*_CFG030[CE_EN,NFE_EN,FE_EN,UR_EN]) */ + { +cvmx_pcieepx_cfg030_t pcieepx_cfg030; + + pcieepx_cfg030.u32 =CVMX_PCIE_CFGX_READ (pcie_port,CVMX_PCIEEPX_CFG030 (pcie_port)); + pcieepx_cfg030.s.mps =MPS_CN6XXX ; + pcieepx_cfg030.s.mrrs =MRRS_CN6XXX ; + pcieepx_cfg030.s.ro_en =1 ;/* Enable relaxed ordering. */ + pcieepx_cfg030.s.ns_en =1 ;/* Enable no snoop. */ + pcieepx_cfg030.s.ce_en =1 ;/* Correctable error reporting enable. */ + pcieepx_cfg030.s.nfe_en =1 ;/* Non-fatal error reporting enable. */ + pcieepx_cfg030.s.fe_en =1 ;/* Fatal error reporting enable. */ + pcieepx_cfg030.s.ur_en =1 ;/* Unsupported request reporting enable. */ +CVMX_PCIE_CFGX_WRITE (pcie_port,CVMX_PCIEEPX_CFG030 (pcie_port), pcieepx_cfg030.u32); + } + +/* Max Payload Size (DPI_SLI_PRTX_CFG[MPS]) must match +* PCIE*_CFG030[MPS] +*/ +/* Max Read Request Size (DPI_SLI_PRTX_CFG[MRRS]) must not +* exceed PCIE*_CFG030[MRRS] +*/ +cvmx_dpi_sli_prtx_cfg_t prt_cfg; +cvmx_sli_s2m_portx_ctl_t sli_s2m_portx_ctl; + + prt_cfg.u64 =CVMX_READ_CSR (CVMX_DPI_SLI_PRTX_CFG (pcie_port)); + prt_cfg.s.mps =MPS_CN6XXX ; + prt_cfg.s.mrrs =MRRS_CN6XXX ; +/* Max outstanding load request. */ + prt_cfg.s.molr =32 ; +CVMX_WRITE_CSR (CVMX_DPI_SLI_PRTX_CFG (pcie_port), prt_cfg.u64); + + sli_s2m_portx_ctl.u64 =CVMX_READ_CSR (CVMX_PEXP_SLI_S2M_PORTX_CTL (pcie_port)); +if (!(OCTEON_IS_MODEL (OCTEON_CN78XX ) ||OCTEON_IS_MODEL (OCTEON_CN73XX ) || +OCTEON_IS_MODEL (OCTEON_CNF75XX ))) + sli_s2m_portx_ctl.cn61xx.mrrs =MRRS_CN6XXX ; +CVMX_WRITE_CSR (CVMX_PEXP_SLI_S2M_PORTX_CTL (pcie_port), sli_s2m_portx_ctl.u64); + +/* Setup Mem access SubDID 12 to access Host memory */ +cvmx_sli_mem_access_subidx_t mem_access_subid; + + mem_access_subid.u64 =0 ; + mem_access_subid.s.port = pcie_port;/* Port the request is sent to. */ + mem_access_subid.s.nmerge =0 ;/* Merging is allowed in this window. */ + mem_access_subid.s.esr =0 ;/* Endian-swap for Reads. */ + mem_access_subid.s.esw =0 ;/* Endian-swap for Writes. */ + mem_access_subid.s.wtype =0 ;/* "No snoop" and "Relaxed ordering" are not set */ + mem_access_subid.s.rtype =0 ;/* "No snoop" and "Relaxed ordering" are not set */ +/* PCIe Address Bits <63:34>. */ +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) + mem_access_subid.cn68xx.ba =0 ; +else + mem_access_subid.cn63xx.ba =0 ; +CVMX_WRITE_CSR (CVMX_PEXP_SLI_MEM_ACCESS_SUBIDX (12 + pcie_port *4 ), mem_access_subid.u64); + +return 0 ; +} + +/** +* Wait for posted PCIe read/writes to reach the other side of +* the internal PCIe switch. This will insure that core +* read/writes are posted before anything after this function +* is called. This may be necessary when writing to memory that +* will later be read using the DMA/PKT engines. +* +* @param pcie_port PCIe port to wait for +*/ +void cvmx_pcie_wait_for_pending (int pcie_port) +{ +cvmx_sli_data_out_cnt_t sli_data_out_cnt; +int a; +int b; +int c; + + sli_data_out_cnt.u64 =csr_rd (CVMX_PEXP_SLI_DATA_OUT_CNT ); +if (pcie_port) { +if (!sli_data_out_cnt.s.p1_fcnt) +return ; + a = sli_data_out_cnt.s.p1_ucnt; + b = (a + sli_data_out_cnt.s.p1_fcnt -1 ) &0xffff ; + }else { +if (!sli_data_out_cnt.s.p0_fcnt) +return ; + a = sli_data_out_cnt.s.p0_ucnt; + b = (a + sli_data_out_cnt.s.p0_fcnt -1 ) &0xffff ; + } + +while (1 ) { + sli_data_out_cnt.u64 =csr_rd (CVMX_PEXP_SLI_DATA_OUT_CNT ); + c = (pcie_port) ? sli_data_out_cnt.s.p1_ucnt : + sli_data_out_cnt.s.p0_ucnt; +if (a <= b) { +if (c < a || c > b) +return ; + }else { +if (c > b && c < a) +return ; + } + } +} + +/** +* Returns if a PCIe port is in host or target mode. +* +* @param pcie_port PCIe port number (PEM number) +* +* @return 0 if PCIe port is in target mode, !0 if in host mode. +*/ +int cvmx_pcie_is_host_mode (int pcie_port) +{ +int node = (pcie_port >>4 ) &0x3 ; +cvmx_mio_rst_ctlx_t mio_rst_ctl; + + pcie_port &=0x3 ; +if (OCTEON_IS_MODEL (OCTEON_CN78XX ) ||OCTEON_IS_MODEL (OCTEON_CN73XX )) { +cvmx_pemx_strap_t strap; + + strap.u64 =CVMX_READ_CSR (CVMX_PEMX_STRAP (pcie_port)); +return (strap.cn78xx.pimode ==3 ); + }else if (OCTEON_IS_MODEL (OCTEON_CN70XX )) { +cvmx_rst_ctlx_t rst_ctl; + + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (pcie_port)); +return !!rst_ctl.s.host_mode; + } + + mio_rst_ctl.u64 =csr_rd (CVMX_MIO_RST_CTLX (pcie_port)); +if (OCTEON_IS_MODEL (OCTEON_CN61XX ) ||OCTEON_IS_MODEL (OCTEON_CNF71XX )) +return mio_rst_ctl.s.prtmode !=0 ; +else +return !!mio_rst_ctl.s.host_mode; +}
Signature · 1 line
2.29.2
PATCH 42/50 mips: octeon: Add cvmx-qlm.c
In reply to Stefan RoeseFrom: Aaron Williams <[email protected]>
Import cvmx-qlm.c from 2013 U-Boot. It will be used by the later added drivers to support PCIe and networking on the MIPS Octeon II / III platforms.
---
arch/mips/mach-octeon/cvmx-qlm.c | 2350 ++++++++++++++++++++++++++++++ 1 file changed, 2350 insertions(+) create mode 100644 arch/mips/mach-octeon/cvmx-qlm.c
arch/mips/mach-octeon/cvmx-qlm.c new file +2350 -0
@@ -0,0 +1,2350 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Marvell International Ltd. +* +* Helper utilities for qlm. +*/ + +#include <log.h> +#include <time.h> +#include <asm/global_data.h> +#include <linux/delay.h> + +#include <mach/cvmx-regs.h> +#include <mach/octeon-model.h> +#include <mach/cvmx-fuse.h> +#include <mach/octeon-feature.h> +#include <mach/cvmx-qlm.h> +#include <mach/octeon_qlm.h> +#include <mach/cvmx-pcie.h> +#include <mach/cvmx-helper.h> +#include <mach/cvmx-helper-util.h> +#include <mach/cvmx-bgxx-defs.h> +#include <mach/cvmx-ciu-defs.h> +#include <mach/cvmx-gmxx-defs.h> +#include <mach/cvmx-gserx-defs.h> +#include <mach/cvmx-mio-defs.h> +#include <mach/cvmx-pciercx-defs.h> +#include <mach/cvmx-pemx-defs.h> +#include <mach/cvmx-pexp-defs.h> +#include <mach/cvmx-rst-defs.h> +#include <mach/cvmx-sata-defs.h> +#include <mach/cvmx-sli-defs.h> +#include <mach/cvmx-sriomaintx-defs.h> +#include <mach/cvmx-sriox-defs.h> + +#include <mach/cvmx-helper.h> +#include <mach/cvmx-helper-jtag.h> + +DECLARE_GLOBAL_DATA_PTR ; + +/* +* Their is a copy of this in bootloader qlm configuration, make sure +* to update both the places till i figure out +*/ +#define R_25G_REFCLK100 0x0 +#define R_5G_REFCLK100 0x1 +#define R_8G_REFCLK100 0x2 +#define R_125G_REFCLK15625_KX 0x3 +#define R_3125G_REFCLK15625_XAUI 0x4 +#define R_103125G_REFCLK15625_KR 0x5 +#define R_125G_REFCLK15625_SGMII 0x6 +#define R_5G_REFCLK15625_QSGMII 0x7 +#define R_625G_REFCLK15625_RXAUI 0x8 +#define R_25G_REFCLK125 0x9 +#define R_5G_REFCLK125 0xa +#define R_8G_REFCLK125 0xb + +static const int REF_100MHZ =100000000 ; +static const int REF_125MHZ =125000000 ; +static const int REF_156MHZ =156250000 ; + +static qlm_jtag_uint32_t *__cvmx_qlm_jtag_xor_ref; + +/** +* Return the number of QLMs supported by the chip +* +* @return Number of QLMs +*/ +int cvmx_qlm_get_num (void ) +{ +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) +return 5 ; +else if (OCTEON_IS_MODEL (OCTEON_CN66XX )) +return 3 ; +else if (OCTEON_IS_MODEL (OCTEON_CN63XX )) +return 3 ; +else if (OCTEON_IS_MODEL (OCTEON_CN61XX )) +return 3 ; +else if (OCTEON_IS_MODEL (OCTEON_CNF71XX )) +return 2 ; +else if (OCTEON_IS_MODEL (OCTEON_CN78XX )) +return 8 ; +else if (OCTEON_IS_MODEL (OCTEON_CN73XX )) +return 7 ; +else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) +return 9 ; +return 0 ; +} + +/** +* Return the qlm number based on the interface +* +* @param xiface interface to look up +* +* @return the qlm number based on the xiface +*/ +int cvmx_qlm_interface (int xiface) +{ +struct cvmx_xiface xi =cvmx_helper_xiface_to_node_interface (xiface); + +if (OCTEON_IS_MODEL (OCTEON_CN61XX )) { +return (xi.interface ==0 ) ?2 :0 ; + }else if (OCTEON_IS_MODEL (OCTEON_CN63XX ) ||OCTEON_IS_MODEL (OCTEON_CN66XX )) { +return 2 - xi.interface; + }else if (OCTEON_IS_MODEL (OCTEON_CNF71XX )) { +if (xi.interface ==0 ) +return 0 ; + +debug ("Warning: %s: Invalid interface %d\n" , + __func__, xi.interface); + }else if (octeon_has_feature (OCTEON_FEATURE_BGX )) { +debug ("Warning: not supported\n" ); +return -1 ; + } + +/* Must be cn68XX */ +switch (xi.interface) { +case 1 : +return 0 ; +default : +return xi.interface; + } + +return -1 ; +} + +/** +* Return the qlm number based for a port in the interface +* +* @param xiface interface to look up +* @param index index in an interface +* +* @return the qlm number based on the xiface +*/ +int cvmx_qlm_lmac (int xiface,int index) +{ +struct cvmx_xiface xi =cvmx_helper_xiface_to_node_interface (xiface); + +if (OCTEON_IS_MODEL (OCTEON_CN78XX )) { +cvmx_bgxx_cmr_global_config_t gconfig; +cvmx_gserx_phy_ctl_t phy_ctl; +cvmx_gserx_cfg_t gserx_cfg; +int qlm; + +if (xi.interface <6 ) { +if (xi.interface <2 ) { + gconfig.u64 = +csr_rd_node (xi.node, +CVMX_BGXX_CMR_GLOBAL_CONFIG (xi.interface)); +if (gconfig.s.pmux_sds_sel) + qlm = xi.interface +2 ;/* QLM 2 or 3 */ +else + qlm = xi.interface;/* QLM 0 or 1 */ + }else { + qlm = xi.interface +2 ;/* QLM 4-7 */ + } + +/* make sure the QLM is powered up and out of reset */ + phy_ctl.u64 =csr_rd_node (xi.node,CVMX_GSERX_PHY_CTL (qlm)); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; + gserx_cfg.u64 =csr_rd_node (xi.node,CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.bgx) +return qlm; +else +return -1 ; + }else if (xi.interface <=7 ) {/* ILK */ +int qlm; + +for (qlm =4 ; qlm <8 ; qlm++) { +/* Make sure the QLM is powered and out of reset */ + phy_ctl.u64 =csr_rd_node (xi.node,CVMX_GSERX_PHY_CTL (qlm)); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +continue ; +/* Make sure the QLM is in ILK mode */ + gserx_cfg.u64 =csr_rd_node (xi.node,CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.ila) +return qlm; + } + } +return -1 ; + }else if (OCTEON_IS_MODEL (OCTEON_CN73XX )) { +cvmx_gserx_phy_ctl_t phy_ctl; +cvmx_gserx_cfg_t gserx_cfg; +int qlm; + +/* (interface)0->QLM2, 1->QLM3, 2->DLM5/3->DLM6 */ +if (xi.interface <2 ) { + qlm = xi.interface +2 ;/* (0,1)->ret(2,3) */ + + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (qlm)); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; + + gserx_cfg.u64 =csr_rd (CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.bgx) +return qlm; +else +return -1 ; + }else if (xi.interface ==2 ) { +cvmx_gserx_cfg_t g1, g2; + + g1.u64 =csr_rd (CVMX_GSERX_CFG (5 )); + g2.u64 =csr_rd (CVMX_GSERX_CFG (6 )); +/* Check if both QLM5 & QLM6 are BGX2 */ +if (g2.s.bgx) { +if (g1.s.bgx) { +cvmx_gserx_phy_ctl_t phy_ctl1; + + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (5 )); + phy_ctl1.u64 =csr_rd (CVMX_GSERX_PHY_CTL (6 )); +if ((phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) && + (phy_ctl1.s.phy_pd || phy_ctl1.s.phy_reset)) +return -1 ; +if (index >=2 ) +return 6 ; +return 5 ; + }else {/* QLM6 is BGX2 */ + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (6 )); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; +return 6 ; + } + }else if (g1.s.bgx) { + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (5 )); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; +return 5 ; + } + } +return -1 ; + }else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) { +cvmx_gserx_phy_ctl_t phy_ctl; +cvmx_gserx_cfg_t gserx_cfg; +int qlm; + +if (xi.interface ==0 ) { +cvmx_gserx_cfg_t g1, g2; + + g1.u64 =csr_rd (CVMX_GSERX_CFG (4 )); + g2.u64 =csr_rd (CVMX_GSERX_CFG (5 )); +/* Check if both QLM4 & QLM5 are BGX0 */ +if (g2.s.bgx) { +if (g1.s.bgx) { +cvmx_gserx_phy_ctl_t phy_ctl1; + + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (4 )); + phy_ctl1.u64 =csr_rd (CVMX_GSERX_PHY_CTL (5 )); +if ((phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) && + (phy_ctl1.s.phy_pd || phy_ctl1.s.phy_reset)) +return -1 ; +if (index >=2 ) +return 5 ; +return 4 ; + } + +/* QLM5 is BGX0 */ + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (5 )); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; +return 5 ; + }else if (g1.s.bgx) { + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (4 )); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; +return 4 ; + } + }else if (xi.interface <2 ) { + qlm = (xi.interface ==1 ) ?2 :3 ; + gserx_cfg.u64 =csr_rd (CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.srio) +return qlm; + } +return -1 ; + } +return -1 ; +} + +/** +* Return if only DLM5/DLM6/DLM5+DLM6 is used by BGX +* +* @param BGX BGX to search for. +* +* @return muxes used 0 = DLM5+DLM6, 1 = DLM5, 2 = DLM6. +*/ +int cvmx_qlm_mux_interface (int bgx) +{ +int mux =0 ; +cvmx_gserx_cfg_t gser1, gser2; +int qlm1, qlm2; + +if (OCTEON_IS_MODEL (OCTEON_CN73XX ) && bgx !=2 ) +return -1 ; +else if (OCTEON_IS_MODEL (OCTEON_CNF75XX ) && bgx !=0 ) +return -1 ; + +if (OCTEON_IS_MODEL (OCTEON_CN73XX )) { + qlm1 =5 ; + qlm2 =6 ; + }else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) { + qlm1 =4 ; + qlm2 =5 ; + }else { +return -1 ; + } + + gser1.u64 =csr_rd (CVMX_GSERX_CFG (qlm1)); + gser2.u64 =csr_rd (CVMX_GSERX_CFG (qlm2)); + +if (gser1.s.bgx && gser2.s.bgx) + mux =0 ; +else if (gser1.s.bgx) + mux =1 ;// BGX2 is using DLM5 only +else if (gser2.s.bgx) + mux =2 ;// BGX2 is using DLM6 only + +return mux; +} + +/** +* Return number of lanes for a given qlm +* +* @param qlm QLM to examine +* +* @return Number of lanes +*/ +int cvmx_qlm_get_lanes (int qlm) +{ +if (OCTEON_IS_MODEL (OCTEON_CN61XX ) && qlm ==1 ) +return 2 ; +else if (OCTEON_IS_MODEL (OCTEON_CNF71XX )) +return 2 ; +else if (OCTEON_IS_MODEL (OCTEON_CN73XX )) +return (qlm <4 ) ?4 /*QLM0,1,2,3*/ :2 /*DLM4,5,6*/ ; +else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) +return (qlm ==2 || qlm ==3 ) ?4 /*QLM2,3*/ :2 /*DLM0,1,4,5*/ ; +return 4 ; +} + +/** +* Get the QLM JTAG fields based on Octeon model on the supported chips. +* +* @return qlm_jtag_field_t structure +*/ +const __cvmx_qlm_jtag_field_t *cvmx_qlm_jtag_get_field (void ) +{ +/* Figure out which JTAG chain description we're using */ +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) { +return __cvmx_qlm_jtag_field_cn68xx; + }else if (OCTEON_IS_MODEL (OCTEON_CN66XX ) ||OCTEON_IS_MODEL (OCTEON_CN61XX ) || +OCTEON_IS_MODEL (OCTEON_CNF71XX )) { +return __cvmx_qlm_jtag_field_cn66xx; + }else if (OCTEON_IS_MODEL (OCTEON_CN63XX )) { +return __cvmx_qlm_jtag_field_cn63xx; + } + +return NULL ; +} + +/** +* Get the QLM JTAG length by going through qlm_jtag_field for each +* Octeon model that is supported +* +* @return return the length. +*/ +int cvmx_qlm_jtag_get_length (void ) +{ +const __cvmx_qlm_jtag_field_t *qlm_ptr =cvmx_qlm_jtag_get_field (); +int length =0 ; + +/* Figure out how many bits are in the JTAG chain */ +while (qlm_ptr && qlm_ptr->name) { +if (qlm_ptr->stop_bit > length) + length = qlm_ptr->stop_bit +1 ; + qlm_ptr++; + } +return length; +} + +/** +* Initialize the QLM layer +*/ +void cvmx_qlm_init (void ) +{ +if (OCTEON_IS_OCTEON3 ()) +return ; + +/* ToDo: No support for non-Octeon 3 yet */ +printf ("Please add support for unsupported Octeon SoC\n" ); +} + +/** +* Lookup the bit information for a JTAG field name +* +* @param name Name to lookup +* +* @return Field info, or NULL on failure +*/ +static const __cvmx_qlm_jtag_field_t *__cvmx_qlm_lookup_field (const char *name) +{ +const __cvmx_qlm_jtag_field_t *ptr =cvmx_qlm_jtag_get_field (); + +while (ptr->name) { +if (strcmp (name, ptr->name) ==0 ) +return ptr; + ptr++; + } + +debug ("%s: Illegal field name %s\n" , __func__, name); +return NULL ; +} + +/** +* Get a field in a QLM JTAG chain +* +* @param qlm QLM to get +* @param lane Lane in QLM to get +* @param name String name of field +* +* @return JTAG field value +*/ +uint64_t cvmx_qlm_jtag_get (int qlm,int lane,const char *name) +{ +const __cvmx_qlm_jtag_field_t *field =__cvmx_qlm_lookup_field (name); +int qlm_jtag_length =cvmx_qlm_jtag_get_length (); +int num_lanes =cvmx_qlm_get_lanes (qlm); + +if (!field) +return 0 ; + +/* Capture the current settings */ +cvmx_helper_qlm_jtag_capture (qlm); +/* +* Shift past lanes we don't care about. CN6XXX/7XXX shifts lane 0 first, +* CN3XXX/5XXX shifts lane 3 first +*/ +/* Shift to the start of the field */ +cvmx_helper_qlm_jtag_shift_zeros (qlm, + qlm_jtag_length * (num_lanes -1 - lane)); +cvmx_helper_qlm_jtag_shift_zeros (qlm, field->start_bit); +/* Shift out the value and return it */ +return cvmx_helper_qlm_jtag_shift (qlm, field->stop_bit - field->start_bit +1 ,0 ); +} + +/** +* Set a field in a QLM JTAG chain +* +* @param qlm QLM to set +* @param lane Lane in QLM to set, or -1 for all lanes +* @param name String name of field +* @param value Value of the field +*/ +void cvmx_qlm_jtag_set (int qlm,int lane,const char *name,uint64_t value) +{ +int i, l; +u32 shift_values[CVMX_QLM_JTAG_UINT32 ]; +int num_lanes =cvmx_qlm_get_lanes (qlm); +const __cvmx_qlm_jtag_field_t *field =__cvmx_qlm_lookup_field (name); +int qlm_jtag_length =cvmx_qlm_jtag_get_length (); +int total_length = qlm_jtag_length * num_lanes; +int bits =0 ; + +if (!field) +return ; + +/* Get the current state */ +cvmx_helper_qlm_jtag_capture (qlm); +for (i =0 ; i <CVMX_QLM_JTAG_UINT32 ; i++) + shift_values[i] =cvmx_helper_qlm_jtag_shift (qlm,32 ,0 ); + +/* Put new data in our local array */ +for (l =0 ; l < num_lanes; l++) { +u64 new_value = value; +int bits; +int adj_lanes; + +if (l != lane && lane !=-1 ) +continue ; + + adj_lanes = (num_lanes -1 - l) * qlm_jtag_length; + +for (bits = field->start_bit + adj_lanes; bits <= field->stop_bit + adj_lanes; + bits++) { +if (new_value &1 ) + shift_values[bits /32 ] |=1 << (bits &31 ); +else + shift_values[bits /32 ] &= ~(1 << (bits &31 )); + new_value >>=1 ; + } + } + +/* Shift out data and xor with reference */ +while (bits < total_length) { +u32 shift = shift_values[bits /32 ] ^ __cvmx_qlm_jtag_xor_ref[qlm][bits /32 ]; +int width = total_length - bits; + +if (width >32 ) + width =32 ; +cvmx_helper_qlm_jtag_shift (qlm, width, shift); + bits +=32 ; + } + +/* Update the new data */ +cvmx_helper_qlm_jtag_update (qlm); + +/* +* Always give the QLM 1ms to settle after every update. This may not +* always be needed, but some of the options make significant +* electrical changes +*/ +udelay (1000 ); +} + +/** +* Errata G-16094: QLM Gen2 Equalizer Default Setting Change. +* CN68XX pass 1.x and CN66XX pass 1.x QLM tweak. This function tweaks the +* JTAG setting for a QLMs to run better at 5 and 6.25Ghz. +*/ +void __cvmx_qlm_speed_tweak (void ) +{ +cvmx_mio_qlmx_cfg_t qlm_cfg; +int num_qlms =cvmx_qlm_get_num (); +int qlm; + +/* Workaround for Errata (G-16467) */ +if (OCTEON_IS_MODEL (OCTEON_CN68XX_PASS2_X )) { +for (qlm =0 ; qlm < num_qlms; qlm++) { +int ir50dac; + +/* +* This workaround only applies to QLMs running at +* 6.25Ghz +*/ +if (cvmx_qlm_get_gbaud_mhz (qlm) ==6250 ) { +#ifdef CVMX_QLM_DUMP_STATE +debug ("%s:%d: QLM%d: Applying workaround for Errata G-16467\n" , + __func__, __LINE__, qlm); +cvmx_qlm_display_registers (qlm); +debug ("\n" ); +#endif +cvmx_qlm_jtag_set (qlm,-1 ,"cfg_cdr_trunc" ,0 ); +/* Hold the QLM in reset */ +cvmx_qlm_jtag_set (qlm,-1 ,"cfg_rst_n_set" ,0 ); +cvmx_qlm_jtag_set (qlm,-1 ,"cfg_rst_n_clr" ,1 ); +/* Forcfe TX to be idle */ +cvmx_qlm_jtag_set (qlm,-1 ,"cfg_tx_idle_clr" ,0 ); +cvmx_qlm_jtag_set (qlm,-1 ,"cfg_tx_idle_set" ,1 ); +if (OCTEON_IS_MODEL (OCTEON_CN68XX_PASS2_0 )) { + ir50dac =cvmx_qlm_jtag_get (qlm,0 ,"ir50dac" ); +while (++ir50dac <=31 ) +cvmx_qlm_jtag_set (qlm,-1 ,"ir50dac" , ir50dac); + } +cvmx_qlm_jtag_set (qlm,-1 ,"div4_byp" ,0 ); +cvmx_qlm_jtag_set (qlm,-1 ,"clkf_byp" ,16 ); +cvmx_qlm_jtag_set (qlm,-1 ,"serdes_pll_byp" ,1 ); +cvmx_qlm_jtag_set (qlm,-1 ,"spdsel_byp" ,1 ); +#ifdef CVMX_QLM_DUMP_STATE +debug ("%s:%d: QLM%d: Done applying workaround for Errata G-16467\n" , + __func__, __LINE__, qlm); +cvmx_qlm_display_registers (qlm); +debug ("\n\n" ); +#endif +/* +* The QLM will be taken out of reset later +* when ILK/XAUI are initialized. +*/ + } + } + }else if (OCTEON_IS_MODEL (OCTEON_CN68XX_PASS1_X ) || +OCTEON_IS_MODEL (OCTEON_CN66XX_PASS1_X )) { +/* Loop through the QLMs */ +for (qlm =0 ; qlm < num_qlms; qlm++) { +/* Read the QLM speed */ + qlm_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); + +/* If the QLM [email protected] or 5Ghz then program JTAG */ +if (qlm_cfg.s.qlm_spd ==5 || qlm_cfg.s.qlm_spd ==12 || + qlm_cfg.s.qlm_spd ==0 || qlm_cfg.s.qlm_spd ==6 || + qlm_cfg.s.qlm_spd ==11 ) { +cvmx_qlm_jtag_set (qlm,-1 ,"rx_cap_gen2" ,0x1 ); +cvmx_qlm_jtag_set (qlm,-1 ,"rx_eq_gen2" ,0x8 ); + } + } + } +} + +/** +* Errata G-16174: QLM Gen2 PCIe IDLE DAC change. +* CN68XX pass 1.x, CN66XX pass 1.x and CN63XX pass 1.0-2.2 QLM tweak. +* This function tweaks the JTAG setting for a QLMs for PCIe to run better. +*/ +void __cvmx_qlm_pcie_idle_dac_tweak (void ) +{ +int num_qlms =0 ; +int qlm; + +if (OCTEON_IS_MODEL (OCTEON_CN68XX_PASS1_X )) + num_qlms =5 ; +else if (OCTEON_IS_MODEL (OCTEON_CN66XX_PASS1_X )) + num_qlms =3 ; +else if (OCTEON_IS_MODEL (OCTEON_CN63XX )) + num_qlms =3 ; +else +return ; + +/* Loop through the QLMs */ +for (qlm =0 ; qlm < num_qlms; qlm++) +cvmx_qlm_jtag_set (qlm,-1 ,"idle_dac" ,0x2 ); +} + +void __cvmx_qlm_pcie_cfg_rxd_set_tweak (int qlm,int lane) +{ +if (OCTEON_IS_MODEL (OCTEON_CN6XXX ) ||OCTEON_IS_MODEL (OCTEON_CNF71XX )) +cvmx_qlm_jtag_set (qlm, lane,"cfg_rxd_set" ,0x1 ); +} + +/** +* Get the speed (Gbaud) of the QLM in Mhz for a given node. +* +* @param node node of the QLM +* @param qlm QLM to examine +* +* @return Speed in Mhz +*/ +int cvmx_qlm_get_gbaud_mhz_node (int node,int qlm) +{ +cvmx_gserx_lane_mode_t lane_mode; +cvmx_gserx_cfg_t cfg; + +if (!octeon_has_feature (OCTEON_FEATURE_MULTINODE )) +return 0 ; + +if (qlm >=8 ) +return -1 ;/* FIXME for OCI */ +/* Check if QLM is configured */ + cfg.u64 =csr_rd_node (node,CVMX_GSERX_CFG (qlm)); +if (cfg.u64 ==0 ) +return -1 ; +if (cfg.s.pcie) { +int pem =0 ; +cvmx_pemx_cfg_t pemx_cfg; + +switch (qlm) { +case 0 :/* Either PEM0 x4 of PEM0 x8 */ + pem =0 ; +break ; +case 1 :/* Either PEM0 x4 of PEM1 x4 */ + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (0 )); +if (pemx_cfg.cn78xx.lanes8) + pem =0 ; +else + pem =1 ; +break ; +case 2 :/* Either PEM2 x4 of PEM2 x8 */ + pem =2 ; +break ; +case 3 :/* Either PEM2 x8 of PEM3 x4 or x8 */ +/* Can be last 4 lanes of PEM2 */ + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (2 )); +if (pemx_cfg.cn78xx.lanes8) { + pem =2 ; + }else { + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (3 )); +if (pemx_cfg.cn78xx.lanes8) + pem =3 ; +else + pem =2 ; + } +break ; +case 4 :/* Either PEM3 x8 of PEM3 x4 */ + pem =3 ; +break ; +default : +debug ("QLM%d: Should be in PCIe mode\n" , qlm); +break ; + } + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (pem)); +switch (pemx_cfg.s.md) { +case 0 :/* Gen1 */ +return 2500 ; +case 1 :/* Gen2 */ +return 5000 ; +case 2 :/* Gen3 */ +return 8000 ; +default : +return 0 ; + } + }else { + lane_mode.u64 =csr_rd_node (node,CVMX_GSERX_LANE_MODE (qlm)); +switch (lane_mode.s.lmode) { +case R_25G_REFCLK100 : +return 2500 ; +case R_5G_REFCLK100 : +return 5000 ; +case R_8G_REFCLK100 : +return 8000 ; +case R_125G_REFCLK15625_KX : +return 1250 ; +case R_3125G_REFCLK15625_XAUI : +return 3125 ; +case R_103125G_REFCLK15625_KR : +return 10312 ; +case R_125G_REFCLK15625_SGMII : +return 1250 ; +case R_5G_REFCLK15625_QSGMII : +return 5000 ; +case R_625G_REFCLK15625_RXAUI : +return 6250 ; +case R_25G_REFCLK125 : +return 2500 ; +case R_5G_REFCLK125 : +return 5000 ; +case R_8G_REFCLK125 : +return 8000 ; +default : +return 0 ; + } + } +} + +/** +* Get the speed (Gbaud) of the QLM in Mhz. +* +* @param qlm QLM to examine +* +* @return Speed in Mhz +*/ +int cvmx_qlm_get_gbaud_mhz (int qlm) +{ +if (OCTEON_IS_MODEL (OCTEON_CN63XX )) { +if (qlm ==2 ) { +cvmx_gmxx_inf_mode_t inf_mode; + + inf_mode.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); +switch (inf_mode.s.speed) { +case 0 : +return 5000 ;/* 5 Gbaud */ +case 1 : +return 2500 ;/* 2.5 Gbaud */ +case 2 : +return 2500 ;/* 2.5 Gbaud */ +case 3 : +return 1250 ;/* 1.25 Gbaud */ +case 4 : +return 1250 ;/* 1.25 Gbaud */ +case 5 : +return 6250 ;/* 6.25 Gbaud */ +case 6 : +return 5000 ;/* 5 Gbaud */ +case 7 : +return 2500 ;/* 2.5 Gbaud */ +case 8 : +return 3125 ;/* 3.125 Gbaud */ +case 9 : +return 2500 ;/* 2.5 Gbaud */ +case 10 : +return 1250 ;/* 1.25 Gbaud */ +case 11 : +return 5000 ;/* 5 Gbaud */ +case 12 : +return 6250 ;/* 6.25 Gbaud */ +case 13 : +return 3750 ;/* 3.75 Gbaud */ +case 14 : +return 3125 ;/* 3.125 Gbaud */ +default : +return 0 ;/* Disabled */ + } + }else { +cvmx_sriox_status_reg_t status_reg; + + status_reg.u64 =csr_rd (CVMX_SRIOX_STATUS_REG (qlm)); +if (status_reg.s.srio) { +cvmx_sriomaintx_port_0_ctl2_t sriomaintx_port_0_ctl2; + + sriomaintx_port_0_ctl2.u32 = +csr_rd (CVMX_SRIOMAINTX_PORT_0_CTL2 (qlm)); +switch (sriomaintx_port_0_ctl2.s.sel_baud) { +case 1 : +return 1250 ;/* 1.25 Gbaud */ +case 2 : +return 2500 ;/* 2.5 Gbaud */ +case 3 : +return 3125 ;/* 3.125 Gbaud */ +case 4 : +return 5000 ;/* 5 Gbaud */ +case 5 : +return 6250 ;/* 6.250 Gbaud */ +default : +return 0 ;/* Disabled */ + } + }else { +cvmx_pciercx_cfg032_t pciercx_cfg032; + + pciercx_cfg032.u32 =csr_rd (CVMX_PCIERCX_CFG032 (qlm)); +switch (pciercx_cfg032.s.ls) { +case 1 : +return 2500 ; +case 2 : +return 5000 ; +case 4 : +return 8000 ; +default : { +cvmx_mio_rst_boot_t mio_rst_boot; + + mio_rst_boot.u64 =csr_rd (CVMX_MIO_RST_BOOT ); +if (qlm ==0 && mio_rst_boot.s.qlm0_spd ==0xf ) +return 0 ; + +if (qlm ==1 && mio_rst_boot.s.qlm1_spd ==0xf ) +return 0 ; + +/* Best guess I can make */ +return 5000 ; + } + } + } + } + }else if (OCTEON_IS_OCTEON2 ()) { +cvmx_mio_qlmx_cfg_t qlm_cfg; + + qlm_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); +switch (qlm_cfg.s.qlm_spd) { +case 0 : +return 5000 ;/* 5 Gbaud */ +case 1 : +return 2500 ;/* 2.5 Gbaud */ +case 2 : +return 2500 ;/* 2.5 Gbaud */ +case 3 : +return 1250 ;/* 1.25 Gbaud */ +case 4 : +return 1250 ;/* 1.25 Gbaud */ +case 5 : +return 6250 ;/* 6.25 Gbaud */ +case 6 : +return 5000 ;/* 5 Gbaud */ +case 7 : +return 2500 ;/* 2.5 Gbaud */ +case 8 : +return 3125 ;/* 3.125 Gbaud */ +case 9 : +return 2500 ;/* 2.5 Gbaud */ +case 10 : +return 1250 ;/* 1.25 Gbaud */ +case 11 : +return 5000 ;/* 5 Gbaud */ +case 12 : +return 6250 ;/* 6.25 Gbaud */ +case 13 : +return 3750 ;/* 3.75 Gbaud */ +case 14 : +return 3125 ;/* 3.125 Gbaud */ +default : +return 0 ;/* Disabled */ + } + }else if (OCTEON_IS_MODEL (OCTEON_CN70XX )) { +cvmx_gserx_dlmx_mpll_multiplier_t mpll_multiplier; +u64 meas_refclock; +u64 freq; + +/* Measure the reference clock */ + meas_refclock =cvmx_qlm_measure_clock (qlm); +/* Multiply to get the final frequency */ + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); + freq = meas_refclock * mpll_multiplier.s.mpll_multiplier; + freq = (freq +500000 ) /1000000 ; + +return freq; + }else if (OCTEON_IS_MODEL (OCTEON_CN78XX )) { +return cvmx_qlm_get_gbaud_mhz_node (cvmx_get_node_num (), qlm); + }else if (OCTEON_IS_MODEL (OCTEON_CN73XX ) ||OCTEON_IS_MODEL (OCTEON_CNF75XX )) { +cvmx_gserx_lane_mode_t lane_mode; + + lane_mode.u64 =csr_rd (CVMX_GSERX_LANE_MODE (qlm)); +switch (lane_mode.s.lmode) { +case R_25G_REFCLK100 : +return 2500 ; +case R_5G_REFCLK100 : +return 5000 ; +case R_8G_REFCLK100 : +return 8000 ; +case R_125G_REFCLK15625_KX : +return 1250 ; +case R_3125G_REFCLK15625_XAUI : +return 3125 ; +case R_103125G_REFCLK15625_KR : +return 10312 ; +case R_125G_REFCLK15625_SGMII : +return 1250 ; +case R_5G_REFCLK15625_QSGMII : +return 5000 ; +case R_625G_REFCLK15625_RXAUI : +return 6250 ; +case R_25G_REFCLK125 : +return 2500 ; +case R_5G_REFCLK125 : +return 5000 ; +case R_8G_REFCLK125 : +return 8000 ; +default : +return 0 ; + } + } +return 0 ; +} + +static enum cvmx_qlm_mode __cvmx_qlm_get_mode_cn70xx (int qlm) +{ +switch (qlm) { +case 0 :/* DLM0/DLM1 - SGMII/QSGMII/RXAUI */ + { +union cvmx_gmxx_inf_mode inf_mode0, inf_mode1; + + inf_mode0.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); + inf_mode1.u64 =csr_rd (CVMX_GMXX_INF_MODE (1 )); + +/* SGMII0 SGMII1 */ +switch (inf_mode0.s.mode) { +case CVMX_GMX_INF_MODE_SGMII : +switch (inf_mode1.s.mode) { +case CVMX_GMX_INF_MODE_SGMII : +return CVMX_QLM_MODE_SGMII_SGMII ; +case CVMX_GMX_INF_MODE_QSGMII : +return CVMX_QLM_MODE_SGMII_QSGMII ; +default : +return CVMX_QLM_MODE_SGMII_DISABLED ; + } +case CVMX_GMX_INF_MODE_QSGMII : +switch (inf_mode1.s.mode) { +case CVMX_GMX_INF_MODE_SGMII : +return CVMX_QLM_MODE_QSGMII_SGMII ; +case CVMX_GMX_INF_MODE_QSGMII : +return CVMX_QLM_MODE_QSGMII_QSGMII ; +default : +return CVMX_QLM_MODE_QSGMII_DISABLED ; + } +case CVMX_GMX_INF_MODE_RXAUI : +return CVMX_QLM_MODE_RXAUI_1X2 ; +default : +switch (inf_mode1.s.mode) { +case CVMX_GMX_INF_MODE_SGMII : +return CVMX_QLM_MODE_DISABLED_SGMII ; +case CVMX_GMX_INF_MODE_QSGMII : +return CVMX_QLM_MODE_DISABLED_QSGMII ; +default : +return CVMX_QLM_MODE_DISABLED ; + } + } + } +case 1 :/* Sata / pem0 */ + { +union cvmx_gserx_sata_cfg sata_cfg; +union cvmx_pemx_cfg pem0_cfg; + + sata_cfg.u64 =csr_rd (CVMX_GSERX_SATA_CFG (0 )); + pem0_cfg.u64 =csr_rd (CVMX_PEMX_CFG (0 )); + +switch (pem0_cfg.cn70xx.md) { +case CVMX_PEM_MD_GEN2_2LANE : +case CVMX_PEM_MD_GEN1_2LANE : +return CVMX_QLM_MODE_PCIE_1X2 ; +case CVMX_PEM_MD_GEN2_1LANE : +case CVMX_PEM_MD_GEN1_1LANE : +if (sata_cfg.s.sata_en) +/* Both PEM0 and PEM1 */ +return CVMX_QLM_MODE_PCIE_2X1 ; + +/* Only PEM0 */ +return CVMX_QLM_MODE_PCIE_1X1 ; +case CVMX_PEM_MD_GEN2_4LANE : +case CVMX_PEM_MD_GEN1_4LANE : +return CVMX_QLM_MODE_PCIE ; +default : +return CVMX_QLM_MODE_DISABLED ; + } + } +case 2 : { +union cvmx_gserx_sata_cfg sata_cfg; +union cvmx_pemx_cfg pem0_cfg, pem1_cfg, pem2_cfg; + + sata_cfg.u64 =csr_rd (CVMX_GSERX_SATA_CFG (0 )); + pem0_cfg.u64 =csr_rd (CVMX_PEMX_CFG (0 )); + pem1_cfg.u64 =csr_rd (CVMX_PEMX_CFG (1 )); + pem2_cfg.u64 =csr_rd (CVMX_PEMX_CFG (2 )); + +if (sata_cfg.s.sata_en) +return CVMX_QLM_MODE_SATA_2X1 ; +if (pem0_cfg.cn70xx.md ==CVMX_PEM_MD_GEN2_4LANE || + pem0_cfg.cn70xx.md ==CVMX_PEM_MD_GEN1_4LANE ) +return CVMX_QLM_MODE_PCIE ; +if (pem1_cfg.cn70xx.md ==CVMX_PEM_MD_GEN2_2LANE || + pem1_cfg.cn70xx.md ==CVMX_PEM_MD_GEN1_2LANE ) { +return CVMX_QLM_MODE_PCIE_1X2 ; + } +if (pem1_cfg.cn70xx.md ==CVMX_PEM_MD_GEN2_1LANE || + pem1_cfg.cn70xx.md ==CVMX_PEM_MD_GEN1_1LANE ) { +if (pem2_cfg.cn70xx.md ==CVMX_PEM_MD_GEN2_1LANE || + pem2_cfg.cn70xx.md ==CVMX_PEM_MD_GEN1_1LANE ) { +return CVMX_QLM_MODE_PCIE_2X1 ; + }else { +return CVMX_QLM_MODE_PCIE_1X1 ; + } + } +if (pem2_cfg.cn70xx.md ==CVMX_PEM_MD_GEN2_1LANE || + pem2_cfg.cn70xx.md ==CVMX_PEM_MD_GEN1_1LANE ) +return CVMX_QLM_MODE_PCIE_2X1 ; +return CVMX_QLM_MODE_DISABLED ; + } +default : +return CVMX_QLM_MODE_DISABLED ; + } + +return CVMX_QLM_MODE_DISABLED ; +} + +/* +* Get the DLM mode for the interface based on the interface type. +* +* @param interface_type 0 - SGMII/QSGMII/RXAUI interface +* 1 - PCIe +* 2 - SATA +* @param interface interface to use +* @return the qlm mode the interface is +*/ +enum cvmx_qlm_mode cvmx_qlm_get_dlm_mode (int interface_type,int interface) +{ +switch (interface_type) { +case 0 :/* SGMII/QSGMII/RXAUI */ + { +enum cvmx_qlm_mode qlm_mode =__cvmx_qlm_get_mode_cn70xx (0 ); + +switch (interface) { +case 0 : +switch (qlm_mode) { +case CVMX_QLM_MODE_SGMII_SGMII : +case CVMX_QLM_MODE_SGMII_DISABLED : +case CVMX_QLM_MODE_SGMII_QSGMII : +return CVMX_QLM_MODE_SGMII ; +case CVMX_QLM_MODE_QSGMII_QSGMII : +case CVMX_QLM_MODE_QSGMII_DISABLED : +case CVMX_QLM_MODE_QSGMII_SGMII : +return CVMX_QLM_MODE_QSGMII ; +case CVMX_QLM_MODE_RXAUI_1X2 : +return CVMX_QLM_MODE_RXAUI ; +default : +return CVMX_QLM_MODE_DISABLED ; + } +case 1 : +switch (qlm_mode) { +case CVMX_QLM_MODE_SGMII_SGMII : +case CVMX_QLM_MODE_DISABLED_SGMII : +case CVMX_QLM_MODE_QSGMII_SGMII : +return CVMX_QLM_MODE_SGMII ; +case CVMX_QLM_MODE_QSGMII_QSGMII : +case CVMX_QLM_MODE_DISABLED_QSGMII : +case CVMX_QLM_MODE_SGMII_QSGMII : +return CVMX_QLM_MODE_QSGMII ; +default : +return CVMX_QLM_MODE_DISABLED ; + } +default : +return qlm_mode; + } + } +case 1 :/* PCIe */ + { +enum cvmx_qlm_mode qlm_mode1 =__cvmx_qlm_get_mode_cn70xx (1 ); +enum cvmx_qlm_mode qlm_mode2 =__cvmx_qlm_get_mode_cn70xx (2 ); + +switch (interface) { +case 0 :/* PCIe0 can be DLM1 with 1, 2 or 4 lanes */ +return qlm_mode1; +case 1 : +/* +* PCIe1 can be in DLM1 1 lane(1), DLM2 1 lane(0) +* or 2 lanes(0-1) +*/ +if (qlm_mode1 ==CVMX_QLM_MODE_PCIE_2X1 ) +return CVMX_QLM_MODE_PCIE_2X1 ; +else if (qlm_mode2 ==CVMX_QLM_MODE_PCIE_1X2 || + qlm_mode2 ==CVMX_QLM_MODE_PCIE_2X1 ) +return qlm_mode2; +else +return CVMX_QLM_MODE_DISABLED ; +case 2 :/* PCIe2 can be DLM2 1 lanes(1) */ +if (qlm_mode2 ==CVMX_QLM_MODE_PCIE_2X1 ) +return qlm_mode2; +else +return CVMX_QLM_MODE_DISABLED ; +default : +return CVMX_QLM_MODE_DISABLED ; + } + } +case 2 :/* SATA */ + { +enum cvmx_qlm_mode qlm_mode =__cvmx_qlm_get_mode_cn70xx (2 ); + +if (qlm_mode ==CVMX_QLM_MODE_SATA_2X1 ) +return CVMX_QLM_MODE_SATA_2X1 ; +else +return CVMX_QLM_MODE_DISABLED ; + } +default : +return CVMX_QLM_MODE_DISABLED ; + } +} + +static enum cvmx_qlm_mode __cvmx_qlm_get_mode_cn6xxx (int qlm) +{ +cvmx_mio_qlmx_cfg_t qlmx_cfg; + +if (OCTEON_IS_MODEL (OCTEON_CN68XX )) { + qlmx_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); +/* QLM is disabled when QLM SPD is 15. */ +if (qlmx_cfg.s.qlm_spd ==15 ) +return CVMX_QLM_MODE_DISABLED ; + +switch (qlmx_cfg.s.qlm_cfg) { +case 0 :/* PCIE */ +return CVMX_QLM_MODE_PCIE ; +case 1 :/* ILK */ +return CVMX_QLM_MODE_ILK ; +case 2 :/* SGMII */ +return CVMX_QLM_MODE_SGMII ; +case 3 :/* XAUI */ +return CVMX_QLM_MODE_XAUI ; +case 7 :/* RXAUI */ +return CVMX_QLM_MODE_RXAUI ; +default : +return CVMX_QLM_MODE_DISABLED ; + } + }else if (OCTEON_IS_MODEL (OCTEON_CN66XX )) { + qlmx_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); +/* QLM is disabled when QLM SPD is 15. */ +if (qlmx_cfg.s.qlm_spd ==15 ) +return CVMX_QLM_MODE_DISABLED ; + +switch (qlmx_cfg.s.qlm_cfg) { +case 0x9 :/* SGMII */ +return CVMX_QLM_MODE_SGMII ; +case 0xb :/* XAUI */ +return CVMX_QLM_MODE_XAUI ; +case 0x0 :/* PCIE gen2 */ +case 0x8 :/* PCIE gen2 (alias) */ +case 0x2 :/* PCIE gen1 */ +case 0xa :/* PCIE gen1 (alias) */ +return CVMX_QLM_MODE_PCIE ; +case 0x1 :/* SRIO 1x4 short */ +case 0x3 :/* SRIO 1x4 long */ +return CVMX_QLM_MODE_SRIO_1X4 ; +case 0x4 :/* SRIO 2x2 short */ +case 0x6 :/* SRIO 2x2 long */ +return CVMX_QLM_MODE_SRIO_2X2 ; +case 0x5 :/* SRIO 4x1 short */ +case 0x7 :/* SRIO 4x1 long */ +if (!OCTEON_IS_MODEL (OCTEON_CN66XX_PASS1_0 )) +return CVMX_QLM_MODE_SRIO_4X1 ; + fallthrough; +default : +return CVMX_QLM_MODE_DISABLED ; + } + }else if (OCTEON_IS_MODEL (OCTEON_CN63XX )) { +cvmx_sriox_status_reg_t status_reg; +/* For now skip qlm2 */ +if (qlm ==2 ) { +cvmx_gmxx_inf_mode_t inf_mode; + + inf_mode.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); +if (inf_mode.s.speed ==15 ) +return CVMX_QLM_MODE_DISABLED ; +else if (inf_mode.s.mode ==0 ) +return CVMX_QLM_MODE_SGMII ; +else +return CVMX_QLM_MODE_XAUI ; + } + status_reg.u64 =csr_rd (CVMX_SRIOX_STATUS_REG (qlm)); +if (status_reg.s.srio) +return CVMX_QLM_MODE_SRIO_1X4 ; +else +return CVMX_QLM_MODE_PCIE ; + }else if (OCTEON_IS_MODEL (OCTEON_CN61XX )) { + qlmx_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); +/* QLM is disabled when QLM SPD is 15. */ +if (qlmx_cfg.s.qlm_spd ==15 ) +return CVMX_QLM_MODE_DISABLED ; + +switch (qlm) { +case 0 : +switch (qlmx_cfg.s.qlm_cfg) { +case 0 :/* PCIe 1x4 gen2 / gen1 */ +return CVMX_QLM_MODE_PCIE ; +case 2 :/* SGMII */ +return CVMX_QLM_MODE_SGMII ; +case 3 :/* XAUI */ +return CVMX_QLM_MODE_XAUI ; +default : +return CVMX_QLM_MODE_DISABLED ; + } +break ; +case 1 : +switch (qlmx_cfg.s.qlm_cfg) { +case 0 :/* PCIe 1x2 gen2 / gen1 */ +return CVMX_QLM_MODE_PCIE_1X2 ; +case 1 :/* PCIe 2x1 gen2 / gen1 */ +return CVMX_QLM_MODE_PCIE_2X1 ; +default : +return CVMX_QLM_MODE_DISABLED ; + } +break ; +case 2 : +switch (qlmx_cfg.s.qlm_cfg) { +case 2 :/* SGMII */ +return CVMX_QLM_MODE_SGMII ; +case 3 :/* XAUI */ +return CVMX_QLM_MODE_XAUI ; +default : +return CVMX_QLM_MODE_DISABLED ; + } +break ; + } + }else if (OCTEON_IS_MODEL (OCTEON_CNF71XX )) { + qlmx_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); +/* QLM is disabled when QLM SPD is 15. */ +if (qlmx_cfg.s.qlm_spd ==15 ) +return CVMX_QLM_MODE_DISABLED ; + +switch (qlm) { +case 0 : +if (qlmx_cfg.s.qlm_cfg ==2 )/* SGMII */ +return CVMX_QLM_MODE_SGMII ; +break ; +case 1 : +switch (qlmx_cfg.s.qlm_cfg) { +case 0 :/* PCIe 1x2 gen2 / gen1 */ +return CVMX_QLM_MODE_PCIE_1X2 ; +case 1 :/* PCIe 2x1 gen2 / gen1 */ +return CVMX_QLM_MODE_PCIE_2X1 ; +default : +return CVMX_QLM_MODE_DISABLED ; + } +break ; + } + } +return CVMX_QLM_MODE_DISABLED ; +} + +/** +* @INTERNAL +* Decrement the MPLL Multiplier for the DLM as per Errata G-20669 +* +* @param qlm DLM to configure +* @param baud_mhz Speed of the DLM configured at +* @param old_multiplier MPLL_MULTIPLIER value to decrement +*/ +void __cvmx_qlm_set_mult (int qlm,int baud_mhz,int old_multiplier) +{ +cvmx_gserx_dlmx_mpll_multiplier_t mpll_multiplier; +cvmx_gserx_dlmx_ref_clkdiv2_t clkdiv; +u64 meas_refclock, mult; + +if (!OCTEON_IS_MODEL (OCTEON_CN70XX )) +return ; + +if (qlm ==-1 ) +return ; + + meas_refclock =cvmx_qlm_measure_clock (qlm); +if (meas_refclock ==0 ) { +printf ("DLM%d: Reference clock not running\n" , qlm); +return ; + } + +/* +* The baud rate multiplier needs to be adjusted on the CN70XX if +* the reference clock is > 100MHz. +*/ +if (qlm ==0 ) { + clkdiv.u64 =csr_rd (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 )); +if (clkdiv.s.ref_clkdiv2) + baud_mhz *=2 ; + } + mult = (uint64_t )baud_mhz *1000000 + (meas_refclock /2 ); + mult /= meas_refclock; + +/* +* 6. Decrease MPLL_MULTIPLIER by one continually until it reaches +* the desired long-term setting, ensuring that each MPLL_MULTIPLIER +* value is constant for at least 1 msec before changing to the next +* value. The desired long-term setting is as indicated in HRM tables +* 21-1, 21-2, and 21-3. This is not required with the HRM +* sequence. +*/ +do { + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); + mpll_multiplier.s.mpll_multiplier = --old_multiplier; +csr_wr (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 ), mpll_multiplier.u64); +/* Wait for 1 ms */ +udelay (1000 ); + }while (old_multiplier > (int )mult); +} + +enum cvmx_qlm_mode cvmx_qlm_get_mode_cn78xx (int node,int qlm) +{ +cvmx_gserx_cfg_t gserx_cfg; +int qlm_mode[2 ][9 ] = { {-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 }, + {-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 } }; + +if (qlm >=8 ) +return CVMX_QLM_MODE_OCI ; + +if (qlm_mode[node][qlm] !=-1 ) +return qlm_mode[node][qlm]; + + gserx_cfg.u64 =csr_rd_node (node,CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.pcie) { +switch (qlm) { +case 0 :/* Either PEM0 x4 or PEM0 x8 */ +case 1 :/* Either PEM0 x8 or PEM1 x4 */ + { +cvmx_pemx_cfg_t pemx_cfg; + + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (0 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM0 x8 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM0 x4 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +case 2 :/* Either PEM2 x4 or PEM2 x8 */ + { +cvmx_pemx_cfg_t pemx_cfg; + + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (2 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM2 x8 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM2 x4 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +case 3 :/* Either PEM2 x8 or PEM3 x4 or PEM3 x8 */ + { +cvmx_pemx_cfg_t pemx_cfg; + + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (2 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM2 x8 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + } + +/* Can be first 4 lanes of PEM3 */ + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (3 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM3 x8 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM2 x4 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +case 4 :/* Either PEM3 x8 or PEM3 x4 */ + { +cvmx_pemx_cfg_t pemx_cfg; + + pemx_cfg.u64 =csr_rd_node (node,CVMX_PEMX_CFG (3 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM3 x8 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM3 x4 */ + qlm_mode[node][qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +default : + qlm_mode[node][qlm] =CVMX_QLM_MODE_DISABLED ; +break ; + } + }else if (gserx_cfg.s.ila) { + qlm_mode[node][qlm] =CVMX_QLM_MODE_ILK ; + }else if (gserx_cfg.s.bgx) { +cvmx_bgxx_cmrx_config_t cmr_config; +cvmx_bgxx_spux_br_pmd_control_t pmd_control; +int bgx = (qlm <2 ) ? qlm : qlm -2 ; + + cmr_config.u64 =csr_rd_node (node,CVMX_BGXX_CMRX_CONFIG (0 , bgx)); + pmd_control.u64 =csr_rd_node (node,CVMX_BGXX_SPUX_BR_PMD_CONTROL (0 , bgx)); + +switch (cmr_config.s.lmac_type) { +case 0 : + qlm_mode[node][qlm] =CVMX_QLM_MODE_SGMII ; +break ; +case 1 : + qlm_mode[node][qlm] =CVMX_QLM_MODE_XAUI ; +break ; +case 2 : + qlm_mode[node][qlm] =CVMX_QLM_MODE_RXAUI ; +break ; +case 3 : +/* +* Use training to determine if we're in 10GBASE-KR +* or XFI +*/ +if (pmd_control.s.train_en) + qlm_mode[node][qlm] =CVMX_QLM_MODE_10G_KR ; +else + qlm_mode[node][qlm] =CVMX_QLM_MODE_XFI ; +break ; +case 4 : +/* +* Use training to determine if we're in 40GBASE-KR +* or XLAUI +*/ +if (pmd_control.s.train_en) + qlm_mode[node][qlm] =CVMX_QLM_MODE_40G_KR4 ; +else + qlm_mode[node][qlm] =CVMX_QLM_MODE_XLAUI ; +break ; +default : + qlm_mode[node][qlm] =CVMX_QLM_MODE_DISABLED ; +break ; + } + }else { + qlm_mode[node][qlm] =CVMX_QLM_MODE_DISABLED ; + } + +return qlm_mode[node][qlm]; +} + +enum cvmx_qlm_mode __cvmx_qlm_get_mode_cn73xx (int qlm) +{ +cvmx_gserx_cfg_t gserx_cfg; +int qlm_mode[7 ] = {-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 }; + +if (qlm_mode[qlm] !=-1 ) +return qlm_mode[qlm]; + +if (qlm >6 ) { +debug ("Invalid QLM(%d) passed\n" , qlm); +return -1 ; + } + + gserx_cfg.u64 =csr_rd (CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.pcie) { +cvmx_pemx_cfg_t pemx_cfg; + +switch (qlm) { +case 0 :/* Either PEM0 x4 or PEM0 x8 */ +case 1 :/* Either PEM0 x8 or PEM1 x4 */ + { + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (0 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM0 x8 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM0/PEM1 x4 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +case 2 :/* Either PEM2 x4 or PEM2 x8 */ + { + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (2 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM2 x8 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM2 x4 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +case 5 : +case 6 :/* PEM3 x2 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE_1X2 ;/* PEM3 x2 */ +break ; +case 3 :/* Either PEM2 x8 or PEM3 x4 */ + { + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (2 )); +if (pemx_cfg.cn78xx.lanes8) { +/* PEM2 x8 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else { +/* PEM3 x4 */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE ; + } +break ; + } +default : + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; + } + }else if (gserx_cfg.s.bgx) { +cvmx_bgxx_cmrx_config_t cmr_config; +cvmx_bgxx_cmr_rx_lmacs_t bgx_cmr_rx_lmacs; +cvmx_bgxx_spux_br_pmd_control_t pmd_control; +int bgx =0 ; +int start =0 , end =4 , index; +int lane_mask =0 , train_mask =0 ; +int mux =0 ;// 0:BGX2 (DLM5/DLM6), 1:BGX2(DLM5), 2:BGX2(DLM6) + +if (qlm <4 ) { + bgx = qlm -2 ; + }else if (qlm ==5 || qlm ==6 ) { + bgx =2 ; + mux =cvmx_qlm_mux_interface (bgx); +if (mux ==0 ) { + start =0 ; + end =4 ; + }else if (mux ==1 ) { + start =0 ; + end =2 ; + }else if (mux ==2 ) { + start =2 ; + end =4 ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +return qlm_mode[qlm]; + } + } + +for (index = start; index < end; index++) { + cmr_config.u64 =csr_rd (CVMX_BGXX_CMRX_CONFIG (index, bgx)); + pmd_control.u64 =csr_rd (CVMX_BGXX_SPUX_BR_PMD_CONTROL (index, bgx)); + lane_mask |= (cmr_config.s.lmac_type << (index *4 )); + train_mask |= (pmd_control.s.train_en << (index *4 )); + } + +/* Need to include DLM5 lmacs when only DLM6 DLM is used */ +if (mux ==2 ) + bgx_cmr_rx_lmacs.u64 =csr_rd (CVMX_BGXX_CMR_RX_LMACS (2 )); +switch (lane_mask) { +case 0 : +if (mux ==1 ) { + qlm_mode[qlm] =CVMX_QLM_MODE_SGMII_2X1 ; + }else if (mux ==2 ) { + qlm_mode[qlm] =CVMX_QLM_MODE_SGMII_2X1 ; + bgx_cmr_rx_lmacs.s.lmacs =4 ; + } + qlm_mode[qlm] =CVMX_QLM_MODE_SGMII ; +break ; +case 0x1 : + qlm_mode[qlm] =CVMX_QLM_MODE_XAUI ; +break ; +case 0x2 : +if (mux ==1 ) { +// NONE+RXAUI + qlm_mode[qlm] =CVMX_QLM_MODE_RXAUI_1X2 ; + }else if (mux ==0 ) { +// RXAUI+SGMII + qlm_mode[qlm] =CVMX_QLM_MODE_MIXED ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; + } +break ; +case 0x202 : +if (mux ==2 ) { +// RXAUI+RXAUI + qlm_mode[qlm] =CVMX_QLM_MODE_RXAUI_1X2 ; + bgx_cmr_rx_lmacs.s.lmacs =4 ; + }else if (mux ==1 ) { +// RXAUI+RXAUI + qlm_mode[qlm] =CVMX_QLM_MODE_RXAUI_1X2 ; + }else if (mux ==0 ) { + qlm_mode[qlm] =CVMX_QLM_MODE_RXAUI ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; + } +break ; +case 0x22 : + qlm_mode[qlm] =CVMX_QLM_MODE_RXAUI ; +break ; +case 0x3333 : +/* +* Use training to determine if we're in 10GBASE-KR +* or XFI +*/ +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_10G_KR ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_XFI ; +break ; +case 0x4 : +/* +* Use training to determine if we're in 40GBASE-KR +* or XLAUI +*/ +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_40G_KR4 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_XLAUI ; +break ; +case 0x0005 : + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_SGMII ; +break ; +case 0x3335 : +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_10G_KR ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_XFI ; +break ; +case 0x45 : +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_40G_KR4 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_XLAUI ; +break ; +case 0x225 : + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_RXAUI ; +break ; +case 0x15 : + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_XAUI ; +break ; + +case 0x200 : +if (mux ==2 ) { + qlm_mode[qlm] =CVMX_QLM_MODE_RXAUI_1X2 ; + bgx_cmr_rx_lmacs.s.lmacs =4 ; + }else +case 0x205 : +case 0x233 : +case 0x3302 : +case 0x3305 : +if (mux ==0 ) + qlm_mode[qlm] =CVMX_QLM_MODE_MIXED ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; +case 0x3300 : +if (mux ==0 ) { + qlm_mode[qlm] =CVMX_QLM_MODE_MIXED ; + }else if (mux ==2 ) { +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_10G_KR_1X2 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_XFI_1X2 ; + bgx_cmr_rx_lmacs.s.lmacs =4 ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; + } +break ; +case 0x33 : +if (mux ==1 || mux ==2 ) { +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_10G_KR_1X2 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_XFI_1X2 ; +if (mux ==2 ) + bgx_cmr_rx_lmacs.s.lmacs =4 ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; + } +break ; +case 0x0035 : +if (mux ==0 ) + qlm_mode[qlm] =CVMX_QLM_MODE_MIXED ; +else if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_10G_KR_1X1 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_RGMII_XFI_1X1 ; +break ; +case 0x235 : +if (mux ==0 ) + qlm_mode[qlm] =CVMX_QLM_MODE_MIXED ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; +default : + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; + } +if (mux ==2 ) { +csr_wr (CVMX_BGXX_CMR_RX_LMACS (2 ), bgx_cmr_rx_lmacs.u64); +csr_wr (CVMX_BGXX_CMR_TX_LMACS (2 ), bgx_cmr_rx_lmacs.u64); + } + }else if (gserx_cfg.s.sata) { + qlm_mode[qlm] =CVMX_QLM_MODE_SATA_2X1 ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; + } + +return qlm_mode[qlm]; +} + +enum cvmx_qlm_mode __cvmx_qlm_get_mode_cnf75xx (int qlm) +{ +cvmx_gserx_cfg_t gserx_cfg; +int qlm_mode[9 ] = {-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 }; + +if (qlm_mode[qlm] !=-1 ) +return qlm_mode[qlm]; + +if (qlm >9 ) { +debug ("Invalid QLM(%d) passed\n" , qlm); +return -1 ; + } + +if ((qlm ==2 || qlm ==3 ) && (OCTEON_IS_MODEL (OCTEON_CNF75XX ))) { +cvmx_sriox_status_reg_t status_reg; +int port = (qlm ==2 ) ?0 :1 ; + + status_reg.u64 =csr_rd (CVMX_SRIOX_STATUS_REG (port)); +/* FIXME add different width */ +if (status_reg.s.srio) + qlm_mode[qlm] =CVMX_QLM_MODE_SRIO_1X4 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +return qlm_mode[qlm]; + } + + gserx_cfg.u64 =csr_rd (CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.pcie) { +switch (qlm) { +case 0 :/* Either PEM0 x2 or PEM0 x4 */ +case 1 :/* Either PEM1 x2 or PEM0 x4 */ + { +/* FIXME later */ + qlm_mode[qlm] =CVMX_QLM_MODE_PCIE ; +break ; + } +default : + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; + } + }else if (gserx_cfg.s.bgx) { +cvmx_bgxx_cmrx_config_t cmr_config; +cvmx_bgxx_spux_br_pmd_control_t pmd_control; +int bgx =0 ; +int start =0 , end =4 , index; +int lane_mask =0 , train_mask =0 ; +int mux =0 ;// 0:BGX0 (DLM4/DLM5), 1:BGX0(DLM4), 2:BGX0(DLM5) +cvmx_gserx_cfg_t gser1, gser2; + + gser1.u64 =csr_rd (CVMX_GSERX_CFG (4 )); + gser2.u64 =csr_rd (CVMX_GSERX_CFG (5 )); +if (gser1.s.bgx && gser2.s.bgx) { + start =0 ; + end =4 ; + }else if (gser1.s.bgx) { + start =0 ; + end =2 ; + mux =1 ; + }else if (gser2.s.bgx) { + start =2 ; + end =4 ; + mux =2 ; + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +return qlm_mode[qlm]; + } + +for (index = start; index < end; index++) { + cmr_config.u64 =csr_rd (CVMX_BGXX_CMRX_CONFIG (index, bgx)); + pmd_control.u64 =csr_rd (CVMX_BGXX_SPUX_BR_PMD_CONTROL (index, bgx)); + lane_mask |= (cmr_config.s.lmac_type << (index *4 )); + train_mask |= (pmd_control.s.train_en << (index *4 )); + } + +switch (lane_mask) { +case 0 : +if (mux ==1 || mux ==2 ) + qlm_mode[qlm] =CVMX_QLM_MODE_SGMII_2X1 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_SGMII ; +break ; +case 0x3300 : +if (mux ==0 ) + qlm_mode[qlm] =CVMX_QLM_MODE_MIXED ; +else if (mux ==2 ) +if (train_mask) + qlm_mode[qlm] =CVMX_QLM_MODE_10G_KR_1X2 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_XFI_1X2 ; +else + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; +default : + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; +break ; + } + }else { + qlm_mode[qlm] =CVMX_QLM_MODE_DISABLED ; + } + +return qlm_mode[qlm]; +} + +/* +* Read QLM and return mode. +*/ +enum cvmx_qlm_mode cvmx_qlm_get_mode (int qlm) +{ +if (OCTEON_IS_OCTEON2 ()) +return __cvmx_qlm_get_mode_cn6xxx (qlm); +else if (OCTEON_IS_MODEL (OCTEON_CN70XX )) +return __cvmx_qlm_get_mode_cn70xx (qlm); +else if (OCTEON_IS_MODEL (OCTEON_CN78XX )) +return cvmx_qlm_get_mode_cn78xx (cvmx_get_node_num (), qlm); +else if (OCTEON_IS_MODEL (OCTEON_CN73XX )) +return __cvmx_qlm_get_mode_cn73xx (qlm); +else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) +return __cvmx_qlm_get_mode_cnf75xx (qlm); + +return CVMX_QLM_MODE_DISABLED ; +} + +int cvmx_qlm_measure_clock_cn7xxx (int node,int qlm) +{ +cvmx_gserx_cfg_t cfg; +cvmx_gserx_refclk_sel_t refclk_sel; +cvmx_gserx_lane_mode_t lane_mode; + +if (OCTEON_IS_MODEL (OCTEON_CN73XX )) { +if (node !=0 || qlm >=7 ) +return -1 ; + }else if (OCTEON_IS_MODEL (OCTEON_CN78XX )) { +if (qlm >=8 || node >1 ) +return -1 ;/* FIXME for OCI */ + }else { +debug ("%s: Unsupported OCTEON model\n" , __func__); +return -1 ; + } + + cfg.u64 =csr_rd_node (node,CVMX_GSERX_CFG (qlm)); + +if (cfg.s.pcie) { + refclk_sel.u64 =csr_rd_node (node,CVMX_GSERX_REFCLK_SEL (qlm)); +if (refclk_sel.s.pcie_refclk125) +return REF_125MHZ ;/* Ref 125 Mhz */ +else +return REF_100MHZ ;/* Ref 100Mhz */ + } + + lane_mode.u64 =csr_rd_node (node,CVMX_GSERX_LANE_MODE (qlm)); +switch (lane_mode.s.lmode) { +case R_25G_REFCLK100 : +return REF_100MHZ ; +case R_5G_REFCLK100 : +return REF_100MHZ ; +case R_8G_REFCLK100 : +return REF_100MHZ ; +case R_125G_REFCLK15625_KX : +return REF_156MHZ ; +case R_3125G_REFCLK15625_XAUI : +return REF_156MHZ ; +case R_103125G_REFCLK15625_KR : +return REF_156MHZ ; +case R_125G_REFCLK15625_SGMII : +return REF_156MHZ ; +case R_5G_REFCLK15625_QSGMII : +return REF_156MHZ ; +case R_625G_REFCLK15625_RXAUI : +return REF_156MHZ ; +case R_25G_REFCLK125 : +return REF_125MHZ ; +case R_5G_REFCLK125 : +return REF_125MHZ ; +case R_8G_REFCLK125 : +return REF_125MHZ ; +default : +return 0 ; + } +} + +/** +* Measure the reference clock of a QLM on a multi-node setup +* +* @param node node to measure +* @param qlm QLM to measure +* +* @return Clock rate in Hz +*/ +int cvmx_qlm_measure_clock_node (int node,int qlm) +{ +if (octeon_has_feature (OCTEON_FEATURE_MULTINODE )) +return cvmx_qlm_measure_clock_cn7xxx (node, qlm); +else +return cvmx_qlm_measure_clock (qlm); +} + +/** +* Measure the reference clock of a QLM +* +* @param qlm QLM to measure +* +* @return Clock rate in Hz +*/ +int cvmx_qlm_measure_clock (int qlm) +{ +cvmx_mio_ptp_clock_cfg_t ptp_clock; +u64 count; +u64 start_cycle, stop_cycle; +int evcnt_offset =0x10 ; +int incr_count =1 ; +int ref_clock[16 ] = {0 }; + +if (ref_clock[qlm]) +return ref_clock[qlm]; + +if (OCTEON_IS_OCTEON3 () && !OCTEON_IS_MODEL (OCTEON_CN70XX )) +return cvmx_qlm_measure_clock_cn7xxx (cvmx_get_node_num (), qlm); + +if (OCTEON_IS_MODEL (OCTEON_CN70XX ) && qlm ==0 ) { +cvmx_gserx_dlmx_ref_clkdiv2_t ref_clkdiv2; + + ref_clkdiv2.u64 =csr_rd (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 )); +if (ref_clkdiv2.s.ref_clkdiv2) + incr_count =2 ; + } + +/* Fix reference clock for OCI QLMs */ + +/* Disable the PTP event counter while we configure it */ + ptp_clock.u64 =csr_rd (CVMX_MIO_PTP_CLOCK_CFG );/* For CN63XXp1 errata */ + ptp_clock.s.evcnt_en =0 ; +csr_wr (CVMX_MIO_PTP_CLOCK_CFG , ptp_clock.u64); + +/* Count on rising edge, Choose which QLM to count */ + ptp_clock.u64 =csr_rd (CVMX_MIO_PTP_CLOCK_CFG );/* For CN63XXp1 errata */ + ptp_clock.s.evcnt_edge =0 ; + ptp_clock.s.evcnt_in = evcnt_offset + qlm; +csr_wr (CVMX_MIO_PTP_CLOCK_CFG , ptp_clock.u64); + +/* Clear MIO_PTP_EVT_CNT */ +csr_rd (CVMX_MIO_PTP_EVT_CNT );/* For CN63XXp1 errata */ + count =csr_rd (CVMX_MIO_PTP_EVT_CNT ); +csr_wr (CVMX_MIO_PTP_EVT_CNT , -count); + +/* Set MIO_PTP_EVT_CNT to 1 billion */ +csr_wr (CVMX_MIO_PTP_EVT_CNT ,1000000000 ); + +/* Enable the PTP event counter */ + ptp_clock.u64 =csr_rd (CVMX_MIO_PTP_CLOCK_CFG );/* For CN63XXp1 errata */ + ptp_clock.s.evcnt_en =1 ; +csr_wr (CVMX_MIO_PTP_CLOCK_CFG , ptp_clock.u64); + + start_cycle =get_ticks (); +/* Wait for 50ms */ +mdelay (50 ); + +/* Read the counter */ +csr_rd (CVMX_MIO_PTP_EVT_CNT );/* For CN63XXp1 errata */ + count =csr_rd (CVMX_MIO_PTP_EVT_CNT ); + stop_cycle =get_ticks (); + +/* Disable the PTP event counter */ + ptp_clock.u64 =csr_rd (CVMX_MIO_PTP_CLOCK_CFG );/* For CN63XXp1 errata */ + ptp_clock.s.evcnt_en =0 ; +csr_wr (CVMX_MIO_PTP_CLOCK_CFG , ptp_clock.u64); + +/* Clock counted down, so reverse it */ + count =1000000000 - count; + count *= incr_count; + +/* Return the rate */ + ref_clock[qlm] = count * gd->cpu_clk / (stop_cycle - start_cycle); + +return ref_clock[qlm]; +} + +/* +* Perform RX equalization on a QLM +* +* @param node Node the QLM is on +* @param qlm QLM to perform RX equalization on +* @param lane Lane to use, or -1 for all lanes +* +* @return Zero on success, negative if any lane failed RX equalization +*/ +int __cvmx_qlm_rx_equalization (int node,int qlm,int lane) +{ +cvmx_gserx_phy_ctl_t phy_ctl; +cvmx_gserx_br_rxx_ctl_t rxx_ctl; +cvmx_gserx_br_rxx_eer_t rxx_eer; +cvmx_gserx_rx_eie_detsts_t eie_detsts; +int fail, gbaud, l, lane_mask; +enum cvmx_qlm_mode mode; +int max_lanes =cvmx_qlm_get_lanes (qlm); +cvmx_gserx_lane_mode_t lmode; +cvmx_gserx_lane_px_mode_1_t pmode_1; +int pending =0 ; +u64 timeout; + +/* Don't touch QLMs if it is reset or powered down */ + phy_ctl.u64 =csr_rd_node (node,CVMX_GSERX_PHY_CTL (qlm)); +if (phy_ctl.s.phy_pd || phy_ctl.s.phy_reset) +return -1 ; + +/* +* Check whether GSER PRBS pattern matcher is enabled on any of the +* applicable lanes. Can't complete RX Equalization while pattern +* matcher is enabled because it causes errors +*/ +for (l =0 ; l < max_lanes; l++) { +cvmx_gserx_lanex_lbert_cfg_t lbert_cfg; + +if (lane !=-1 && lane != l) +continue ; + + lbert_cfg.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_LBERT_CFG (l, qlm)); +if (lbert_cfg.s.lbert_pm_en ==1 ) +return -1 ; + } + +/* Get Lane Mode */ + lmode.u64 =csr_rd_node (node,CVMX_GSERX_LANE_MODE (qlm)); + +/* +* Check to see if in VMA manual mode is set. If in VMA manual mode +* don't complete rx equalization +*/ + pmode_1.u64 =csr_rd_node (node,CVMX_GSERX_LANE_PX_MODE_1 (lmode.s.lmode, qlm)); +if (pmode_1.s.vma_mm ==1 ) { +#ifdef DEBUG_QLM +debug ("N%d:QLM%d: VMA Manual (manual DFE) selected. Not completing Rx equalization\n" , + node, qlm); +#endif +return 0 ; + } + +if (OCTEON_IS_MODEL (OCTEON_CN78XX )) { + gbaud =cvmx_qlm_get_gbaud_mhz_node (node, qlm); + mode =cvmx_qlm_get_mode_cn78xx (node, qlm); + }else { + gbaud =cvmx_qlm_get_gbaud_mhz (qlm); + mode =cvmx_qlm_get_mode (qlm); + } + +/* Apply RX Equalization for speed >= 8G */ +if (qlm <8 ) { +if (gbaud <6250 ) +return 0 ; + } + +/* Don't run on PCIe Links */ +if (mode ==CVMX_QLM_MODE_PCIE || mode ==CVMX_QLM_MODE_PCIE_1X8 || + mode ==CVMX_QLM_MODE_PCIE_1X2 || mode ==CVMX_QLM_MODE_PCIE_2X1 ) +return -1 ; + + fail =0 ; + +/* +* Before completing Rx equalization wait for +* GSERx_RX_EIE_DETSTS[CDRLOCK] to be set. +* This ensures the rx data is valid +*/ +if (lane ==-1 ) { +/* +* check all 4 Lanes (cdrlock = 1111/b) for CDR Lock with +* lane == -1 +*/ +if (CVMX_WAIT_FOR_FIELD64_NODE (node,CVMX_GSERX_RX_EIE_DETSTS (qlm), + cvmx_gserx_rx_eie_detsts_t, cdrlock, ==, + (1 << max_lanes) -1 ,500 )) { +#ifdef DEBUG_QLM + eie_detsts.u64 =csr_rd_node (node,CVMX_GSERX_RX_EIE_DETSTS (qlm)); +debug ("ERROR: %d:QLM%d: CDR Lock not detected for all 4 lanes. CDR_LOCK(0x%x)\n" , + node, qlm, eie_detsts.s.cdrlock); +#endif +return -1 ; + } + }else { +if (CVMX_WAIT_FOR_FIELD64_NODE (node,CVMX_GSERX_RX_EIE_DETSTS (qlm), + cvmx_gserx_rx_eie_detsts_t, cdrlock, &, (1 << lane), +500 )) { +#ifdef DEBUG_QLM + eie_detsts.u64 =csr_rd_node (node,CVMX_GSERX_RX_EIE_DETSTS (qlm)); +debug ("ERROR: %d:QLM%d: CDR Lock not detected for Lane%d CDR_LOCK(0x%x)\n" , + node, qlm, lane, eie_detsts.s.cdrlock); +#endif +return -1 ; + } + } + +/* +* Errata (GSER-20075) GSER(0..13)_BR_RX3_EER[RXT_ERR] is +* GSER(0..13)_BR_RX2_EER[RXT_ERR]. Since lanes 2-3 trigger@the +* same time, we need to setup lane 3 before we loop through the lanes +*/ +if (OCTEON_IS_MODEL (OCTEON_CN78XX_PASS1_X ) && (lane ==-1 || lane ==3 )) { +/* Enable software control */ + rxx_ctl.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_CTL (3 , qlm)); + rxx_ctl.s.rxt_swm =1 ; +csr_wr_node (node,CVMX_GSERX_BR_RXX_CTL (3 , qlm), rxx_ctl.u64); + +/* Clear the completion flag */ + rxx_eer.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_EER (3 , qlm)); + rxx_eer.s.rxt_esv =0 ; +csr_wr_node (node,CVMX_GSERX_BR_RXX_EER (3 , qlm), rxx_eer.u64); +/* Initiate a new request on lane 2 */ +if (lane ==3 ) { + rxx_eer.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_EER (2 , qlm)); + rxx_eer.s.rxt_eer =1 ; +csr_wr_node (node,CVMX_GSERX_BR_RXX_EER (2 , qlm), rxx_eer.u64); + } + } + +for (l =0 ; l < max_lanes; l++) { +if (lane !=-1 && lane != l) +continue ; + +/* +* Skip lane 3 on 78p1.x due to Errata (GSER-20075). +* Handled above +*/ +if (OCTEON_IS_MODEL (OCTEON_CN78XX_PASS1_X ) && l ==3 ) { +/* +* Need to add lane 3 to pending list for 78xx +* pass 1.x +*/ + pending |=1 <<3 ; +continue ; + } +/* Enable software control */ + rxx_ctl.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_CTL (l, qlm)); + rxx_ctl.s.rxt_swm =1 ; +csr_wr_node (node,CVMX_GSERX_BR_RXX_CTL (l, qlm), rxx_ctl.u64); + +/* Clear the completion flag and initiate a new request */ + rxx_eer.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_EER (l, qlm)); + rxx_eer.s.rxt_esv =0 ; + rxx_eer.s.rxt_eer =1 ; +csr_wr_node (node,CVMX_GSERX_BR_RXX_EER (l, qlm), rxx_eer.u64); + pending |=1 << l; + } + +/* +* Wait for 250ms, approx 10x times measured value, as XFI/XLAUI +* can take 21-23ms, other interfaces can take 2-3ms. +*/ + timeout =get_timer (0 ); + + lane_mask =0 ; +while (pending) { +/* Wait for RX equalization to complete */ +for (l =0 ; l < max_lanes; l++) { + lane_mask =1 << l; +/* Only check lanes that are pending */ +if (!(pending & lane_mask)) +continue ; + +/* +* Read the registers for checking Electrical Idle/CDR +* lock and the status of the RX equalization +*/ + eie_detsts.u64 =csr_rd_node (node,CVMX_GSERX_RX_EIE_DETSTS (qlm)); + rxx_eer.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_EER (l, qlm)); + +/* +* Mark failure if lane entered Electrical Idle or lost +* CDR Lock. The bit for the lane will have cleared in +* either EIESTS or CDRLOCK +*/ +if (!(eie_detsts.s.eiests & eie_detsts.s.cdrlock & lane_mask)) { + fail |= lane_mask; + pending &= ~lane_mask; + }else if (rxx_eer.s.rxt_esv) { + pending &= ~lane_mask; + } + } + +/* Breakout of the loop on timeout */ +if (get_timer (timeout) >250 ) +break ; + } + + lane_mask =0 ; +/* Cleanup and report status */ +for (l =0 ; l < max_lanes; l++) { +if (lane !=-1 && lane != l) +continue ; + + lane_mask =1 << l; + rxx_eer.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_EER (l, qlm)); +/* Switch back to hardware control */ + rxx_ctl.u64 =csr_rd_node (node,CVMX_GSERX_BR_RXX_CTL (l, qlm)); + rxx_ctl.s.rxt_swm =0 ; +csr_wr_node (node,CVMX_GSERX_BR_RXX_CTL (l, qlm), rxx_ctl.u64); + +/* Report status */ +if (fail & lane_mask) { +#ifdef DEBUG_QLM +debug ("%d:QLM%d: Lane%d RX equalization lost CDR Lock or entered Electrical Idle\n" , + node, qlm, l); +#endif + }else if ((pending & lane_mask) || !rxx_eer.s.rxt_esv) { +#ifdef DEBUG_QLM +debug ("%d:QLM%d: Lane %d RX equalization timeout\n" , node, qlm, l); +#endif + fail |=1 << l; + }else { +#ifdef DEBUG_QLM +char *dir_label[4 ] = {"Hold" ,"Inc" ,"Dec" ,"Hold" }; +#ifdef DEBUG_QLM_RX +cvmx_gserx_lanex_rx_aeq_out_0_t rx_aeq_out_0; +cvmx_gserx_lanex_rx_aeq_out_1_t rx_aeq_out_1; +cvmx_gserx_lanex_rx_aeq_out_2_t rx_aeq_out_2; +cvmx_gserx_lanex_rx_vma_status_0_t rx_vma_status_0; +#endif +debug ("%d:QLM%d: Lane%d: RX equalization completed.\n" , node, qlm, l); +debug (" Tx Direction Hints TXPRE: %s, TXMAIN: %s, TXPOST: %s, Figure of Merit: %d\n" , + dir_label[(rxx_eer.s.rxt_esm) &0x3 ], + dir_label[((rxx_eer.s.rxt_esm) >>2 ) &0x3 ], + dir_label[((rxx_eer.s.rxt_esm) >>4 ) &0x3 ], rxx_eer.s.rxt_esm >>6 ); + +#ifdef DEBUG_QLM_RX + rx_aeq_out_0.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_AEQ_OUT_0 (l, qlm)); + rx_aeq_out_1.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_AEQ_OUT_1 (l, qlm)); + rx_aeq_out_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_AEQ_OUT_2 (l, qlm)); + rx_vma_status_0.u64 = +csr_rd_node (node,CVMX_GSERX_LANEX_RX_VMA_STATUS_0 (l, qlm)); +debug (" DFE Tap1:%lu, Tap2:%ld, Tap3:%ld, Tap4:%ld, Tap5:%ld\n" , + (unsigned int long )cvmx_bit_extract (rx_aeq_out_1.u64,0 ,5 ), + (unsigned int long )cvmx_bit_extract_smag (rx_aeq_out_1.u64,5 ,9 ), + (unsigned int long )cvmx_bit_extract_smag (rx_aeq_out_1.u64,10 ,14 ), + (unsigned int long )cvmx_bit_extract_smag (rx_aeq_out_0.u64,0 ,4 ), + (unsigned int long )cvmx_bit_extract_smag (rx_aeq_out_0.u64,5 ,9 )); +debug (" Pre-CTLE Gain:%lu, Post-CTLE Gain:%lu, CTLE Peak:%lu, CTLE Pole:%lu\n" , + (unsigned int long )cvmx_bit_extract (rx_aeq_out_2.u64,4 ,4 ), + (unsigned int long )cvmx_bit_extract (rx_aeq_out_2.u64,0 ,4 ), + (unsigned int long )cvmx_bit_extract (rx_vma_status_0.u64,2 ,4 ), + (unsigned int long )cvmx_bit_extract (rx_vma_status_0.u64,0 ,2 )); +#endif +#endif + } + } + +return (fail) ?-1 :0 ; +} + +/** +* Errata GSER-27882 -GSER 10GBASE-KR Transmit Equalizer +* Training may not update PHY Tx Taps. This function is not static +* so we can share it with BGX KR +* +* @param node Node to apply errata workaround +* @param qlm QLM to apply errata workaround +* @param lane Lane to apply the errata +*/ +int cvmx_qlm_gser_errata_27882 (int node,int qlm,int lane) +{ +cvmx_gserx_lanex_pcs_ctlifc_0_t clifc0; +cvmx_gserx_lanex_pcs_ctlifc_2_t clifc2; + +if (!(OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_0 ) ||OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_1 ) || +OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_2 ) ||OCTEON_IS_MODEL (OCTEON_CNF75XX_PASS1_0 ) || +OCTEON_IS_MODEL (OCTEON_CN78XX ))) +return 0 ; + +if (CVMX_WAIT_FOR_FIELD64_NODE (node,CVMX_GSERX_RX_EIE_DETSTS (qlm), + cvmx_gserx_rx_eie_detsts_t, cdrlock, &, + (1 << lane),200 )) +return -1 ; + + clifc0.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_0 (lane, qlm)); + clifc0.s.cfg_tx_coeff_req_ovrrd_val =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_0 (lane, qlm), clifc0.u64); + clifc2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + clifc2.s.cfg_tx_coeff_req_ovrrd_en =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), clifc2.u64); + clifc2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + clifc2.s.ctlifc_ovrrd_req =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), clifc2.u64); + clifc2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + clifc2.s.cfg_tx_coeff_req_ovrrd_en =0 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), clifc2.u64); + clifc2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + clifc2.s.ctlifc_ovrrd_req =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), clifc2.u64); +return 0 ; +} + +/** +* Updates the RX EQ Default Settings Update (CTLE Bias) to support longer +* SERDES channels +* +* @INTERNAL +* +* @param node Node number to configure +* @param qlm QLM number to configure +*/ +void cvmx_qlm_gser_errata_25992 (int node,int qlm) +{ +int lane; +int num_lanes =cvmx_qlm_get_lanes (qlm); + +if (!(OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_0 ) ||OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_1 ) || +OCTEON_IS_MODEL (OCTEON_CN73XX_PASS1_2 ) ||OCTEON_IS_MODEL (OCTEON_CN78XX_PASS1_X ))) +return ; + +for (lane =0 ; lane < num_lanes; lane++) { +cvmx_gserx_lanex_rx_ctle_ctrl_t rx_ctle_ctrl; +cvmx_gserx_lanex_rx_cfg_4_t rx_cfg_4; + + rx_ctle_ctrl.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_CTLE_CTRL (lane, qlm)); + rx_ctle_ctrl.s.pcs_sds_rx_ctle_bias_ctrl =3 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_CTLE_CTRL (lane, qlm), rx_ctle_ctrl.u64); + + rx_cfg_4.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_CFG_4 (lane, qlm)); + rx_cfg_4.s.cfg_rx_errdet_ctrl =0xcd6f ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_CFG_4 (lane, qlm), rx_cfg_4.u64); + } +} + +void cvmx_qlm_display_registers (int qlm) +{ +int num_lanes =cvmx_qlm_get_lanes (qlm); +int lane; +const __cvmx_qlm_jtag_field_t *ptr =cvmx_qlm_jtag_get_field (); + +debug ("%29s" ,"Field[<stop bit>:<start bit>]" ); +for (lane =0 ; lane < num_lanes; lane++) +debug ("\t Lane %d" , lane); +debug ("\n" ); + +while (ptr && ptr->name) { +debug ("%20s[%3d:%3d]" , ptr->name, ptr->stop_bit, ptr->start_bit); +for (lane =0 ; lane < num_lanes; lane++) { +u64 val; +int tx_byp =0 ; + +/* +* Make sure serdes_tx_byp is set for displaying +* TX amplitude and TX demphasis field values. +*/ +if (strncmp (ptr->name,"biasdrv_" ,8 ) ==0 || +strncmp (ptr->name,"tcoeff_" ,7 ) ==0 ) { + tx_byp =cvmx_qlm_jtag_get (qlm, lane,"serdes_tx_byp" ); +if (tx_byp ==0 ) { +debug ("\t \t" ); +continue ; + } + } + val =cvmx_qlm_jtag_get (qlm, lane, ptr->name); +debug ("\t%4llu (0x%04llx)" , (unsigned long long )val, + (unsigned long long )val); + } +debug ("\n" ); + ptr++; + } +} + +/* ToDo: CVMX_DUMP_GSER removed for now (unused!) */
Signature · 1 line
2.29.2
PATCH 43/50 mips: octeon: Add octeon_fdt.c
In reply to Stefan RoeseFrom: Aaron Williams <[email protected]>
Import octeon_fdt.c from 2013 U-Boot. It will be used by the later added drivers to support PCIe and networking on the MIPS Octeon II / III platforms.
---
arch/mips/mach-octeon/octeon_fdt.c | 1040 ++++++++++++++++++++++++++++ 1 file changed, 1040 insertions(+) create mode 100644 arch/mips/mach-octeon/octeon_fdt.c
arch/mips/mach-octeon/octeon_fdt.c new file +1040 -0
@@ -0,0 +1,1040 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Marvell International Ltd. +*/ + +#include <env.h> +#include <log.h> +#include <i2c.h> +#include <net.h> +#include <dm/device.h> +#include <linux/delay.h> + +#include <mach/cvmx-regs.h> +#include <mach/cvmx-csr.h> +#include <mach/cvmx-bootmem.h> +#include <mach/octeon-model.h> +#include <mach/octeon_eth.h> +#include <mach/octeon_fdt.h> +#include <mach/cvmx-helper-fdt.h> +#include <mach/cvmx-helper-gpio.h> +#include <mach/cvmx-fuse.h> +#include <mach/octeon-feature.h> +#include <mach/cvmx-qlm.h> +#include <mach/octeon_qlm.h> +#include <asm/gpio.h> + +#ifdef CONFIG_PCA953X +#include <pca953x.h> +#endif +#ifdef CONFIG_PCF857X +#include <pcf857x.h> +#endif +#ifdef CONFIG_PCA9698 +#include <pca9698.h> +#endif +#ifdef CONFIG_PCA9554 +#include <pca9554.h> +#endif +#ifdef CONFIG_PCA9555 +#include <pca9555.h> +#endif + +DECLARE_GLOBAL_DATA_PTR ; + +#ifdef CONFIG_PCA9554 +static const char *const pca9554_gpio_list[] = { +"pca9554" , +"nxp,pca9554" , +"ti,pca9554" , +NULL , +}; +#endif + +#ifdef CONFIG_PCA9555 +static const char *const pca9555_gpio_list[] = { +"pca9535" ,"nxp,pca9535" ,"pca9539" ,"nxp,pca9539" ,"pca9555" , +"nxp,pca9555" ,"ti,pca9555" ,"max7312" ,"maxim,max7312" ,"max7313" , +"maxim,max7313" ,"tca6416" ,"tca9539" ,NULL , +}; +#endif + +#ifdef CONFIG_PCA9698 +/** List of compatible strings supported by pca9698 driver */ +static const char *const pca9698_gpio_list[] = { +"nxp,pca9505" ,"pca9505" ,"nxp,pca9698" ,"pca9698" ,NULL , +}; +#endif + +#ifdef CONFIG_PCA953X +/** List of compatible strings supported by pca953x driver */ +static const char *const pca953x_gpio_list[] = { +"nxp,pca9534" ,"nxp,pca9535" ,"nxp,pca9536" ,"nxp,pca9537" ,"nxp,pca9538" ,"nxp,pca9539" , +"nxp,pca953x" ,"nxp,pca9554" ,"nxp,pca9555" ,"nxp,pca9556" ,"nxp,pca9557" ,"nxp,pca6107" , +"pca9534" ,"pca9535" ,"pca9536" ,"pca9537" ,"pca9538" ,"pca9539" , +"pca953x" ,"pca9554" ,"pca9555" ,"pca9556" ,"pca9557" ,"max7310" , +"max7312" ,"max7313" ,"max7315" ,"pca6107" ,"tca6408" ,"tca6416" , +"tca9555" ,NULL +}; +#endif + +#ifdef CONFIG_PHY_VITESSE +static const char *const vitesse_vsc8488_gpio_list[] = { +"vitesse,vsc8486" ,"microsemi,vsc8486" ,"vitesse,vsc8488" , +"microsemi,vsc8488" ,"vitesse,vsc8489" ,"microsemi,vsc8489" , +"vitesse,vsc8490" ,"microsemi,vsc8490" ,NULL +}; +#endif + +/** List of compatible strings supported by Octeon driver */ +static const char *const octeon_gpio_list[] = { +"cavium,octeon-7890-gpio" , +"cavium,octeon-3860-gpio" , +NULL +}; + +/** +* Trims nodes from the flat device tree. +* +* @param fdt - pointer to working FDT, usually in gd->fdt_blob +* @param fdt_key - key to preserve. All non-matching keys are removed +* @param trim_name - name of property to look for. If NULL use +* 'cavium,qlm-trim' +* +* The key should look something like device #, type where device # is a +* number from 0-9 and type is a string describing the type. For QLM +* operations this would typically contain the QLM number followed by +* the type in the device tree, like "0,xaui", "0,sgmii", etc. This function +* will trim all items in the device tree which match the device number but +* have a type which does not match. For example, if a QLM has a xaui module +* installed on QLM 0 and "0,xaui" is passed as a key, then all FDT nodes that +* have "0,xaui" will be preserved but all others, i.e. "0,sgmii" will be +* removed. +* +* Note that the trim_name must also match. If trim_name is NULL then it +* looks for the property "cavium,qlm-trim". +* +* Also, when the trim_name is "cavium,qlm-trim" or NULL that the interfaces +* will also be renamed based on their register values. +* +* For example, if a PIP interface is named "interface at W" and has the property +* reg = <0> then the interface will be renamed after this function to +* interface at 0. +* +* @return 0 for success. +*/ +int __octeon_fdt_patch (void *fdt,const char *fdt_key,const char *trim_name) +{ +bool rename = !trim_name || !strcmp (trim_name,"cavium,qlm-trim" ); + +return octeon_fdt_patch_rename (fdt, fdt_key, trim_name, rename,NULL ,NULL ); +} + +int octeon_fdt_patch (void *fdt,const char *fdt_key,const char *trim_name) + __attribute__((weak,alias ("__octeon_fdt_patch" ))); + +/** +* Trims nodes from the flat device tree. +* +* @param fdt - pointer to working FDT, usually in gd->fdt_blob +* @param fdt_key - key to preserve. All non-matching keys are removed +* @param trim_name - name of property to look for. If NULL use +* 'cavium,qlm-trim' +* @param rename - set to TRUE to rename interfaces. +* @param callback - function to call on matched nodes. +* @param cbarg - passed to callback. +* +* The key should look something like device #, type where device # is a +* number from 0-9 and type is a string describing the type. For QLM +* operations this would typically contain the QLM number followed by +* the type in the device tree, like "0,xaui", "0,sgmii", etc. This function +* will trim all items in the device tree which match the device number but +* have a type which does not match. For example, if a QLM has a xaui module +* installed on QLM 0 and "0,xaui" is passed as a key, then all FDT nodes that +* have "0,xaui" will be preserved but all others, i.e. "0,sgmii" will be +* removed. +* +* Note that the trim_name must also match. If trim_name is NULL then it +* looks for the property "cavium,qlm-trim". +* +* Also, when the trim_name is "cavium,qlm-trim" or NULL that the interfaces +* will also be renamed based on their register values. +* +* For example, if a PIP interface is named "interface at W" and has the property +* reg = <0> then the interface will be renamed after this function to +* interface at 0. +* +* @return 0 for success. +*/ +int octeon_fdt_patch_rename (void *fdt,const char *fdt_key, +const char *trim_name,bool rename, +void (*callback)(void *fdt,int offset,void *arg), +void *cbarg) + __attribute__((weak,alias ("__octeon_fdt_patch_rename" ))); + +int __octeon_fdt_patch_rename (void *fdt,const char *fdt_key, +const char *trim_name,bool rename, +void (*callback)(void *fdt,int offset,void *arg), +void *cbarg) +{ +int fdt_key_len; +int offset, next_offset; +int aliases; +const void *aprop; +char qlm[32 ]; +char *mode; +int qlm_key_len; +int rc; +int cpu_node; + +if (!trim_name) + trim_name ="cavium,qlm-trim" ; + +strncpy (qlm, fdt_key,sizeof (qlm)); + mode = qlm; +strsep (&mode,"," ); + qlm_key_len =strlen (qlm); + +debug ("In %s: Patching FDT header at 0x%p with key \"%s\"\n" , __func__, fdt, fdt_key); +if (!fdt ||fdt_check_header (fdt) !=0 ) { +printf ("%s: Invalid device tree\n" , __func__); +return -1 ; + } + + fdt_key_len =strlen (fdt_key) +1 ; + +/* Prune out the unwanted parts based on the QLM mode. */ + offset =0 ; +for (offset =fdt_next_node (fdt, offset,NULL ); offset >=0 ; offset = next_offset) { +int len; +const char *val; +const char *val_comma; + + next_offset =fdt_next_node (fdt, offset,NULL ); + + val =fdt_getprop (fdt, offset, trim_name, &len); +if (!val) +continue ; + +debug ("fdt found trim name %s, comparing key \"%s\"(%d) with \"%s\"(%d)\n" , + trim_name, fdt_key, fdt_key_len, val, len); + val_comma =strchr (val,',' ); +if (!val_comma || (val_comma - val) != qlm_key_len) +continue ; +if (strncmp (val, qlm, qlm_key_len) !=0 ) +continue ;/* Not this QLM. */ + +debug ("fdt key number \"%s\" matches\n" , val); +if (!fdt_stringlist_contains (val, len, fdt_key)) { +debug ("Key \"%s\" does not match \"%s\"\n" , val, fdt_key); +/* This QLM, but wrong mode. Delete it. */ +/* See if there's an alias that needs deleting */ + val =fdt_getprop (fdt, offset,"cavium,qlm-trim-alias" ,NULL ); +if (val) { +debug ("Trimming alias \"%s\"\n" , val); + aliases =fdt_path_offset (fdt,"/aliases" ); +if (aliases) { + aprop =fdt_getprop (fdt, aliases, val,NULL ); +if (aprop) { + rc =fdt_nop_property (fdt, aliases, val); +if (rc) { +printf ("Error: Could not NOP alias %s in fdt\n" , + val); + } + }else { +printf ("Error: could not find /aliases/%s in device tree\n" , + val); + } + }else { +puts ("Error: could not find /aliases in device tree\n" ); + } + } +debug ("fdt trimming matching key %s\n" , fdt_key); + next_offset =fdt_parent_offset (fdt, offset); + rc =fdt_nop_node (fdt, offset); +if (rc) +printf ("Error %d noping node in device tree\n" , rc); + } + } + +debug ("%s: Starting pass 2 for key %s\n" , __func__, fdt_key); +/* Second pass: Rewrite names and remove key properties. */ + offset =-1 ; +for (offset =fdt_next_node (fdt, offset,NULL ); offset >=0 ; offset = next_offset) { +int len; +const char *val =fdt_getprop (fdt, offset, trim_name, &len); + + next_offset =fdt_next_node (fdt, offset,NULL ); + +if (!val) +continue ; +debug ("Searching stringlist %s for %s\n" , val, fdt_key); +if (fdt_stringlist_contains (val, len, fdt_key)) { +char new_name[64 ]; +const char *name; +const char *at; +int reg; + +debug ("Found key %s at offset 0x%x\n" , fdt_key, offset); +fdt_nop_property (fdt, offset, trim_name); + +if (rename) { + name =fdt_get_name (fdt, offset,NULL ); +debug (" name: %s\n" , name); +if (!name) +continue ; + at =strchr (name,'@' ); +if (!at) +continue ; + + reg =fdtdec_get_int (fdt, offset,"reg" ,-1 ); +if (reg ==-1 ) +continue ; + +debug (" reg: %d\n" , reg); + len = at - name +1 ; +debug (" len: %d\n" , len); +if (len +9 >=sizeof (new_name)) +continue ; + +memcpy (new_name, name, len); + cpu_node =cvmx_fdt_get_cpu_node (fdt, offset); +if (cpu_node >0 ) +snprintf (new_name + len,sizeof (new_name) - len,"%x_%x" , + cpu_node, reg); +else +sprintf (new_name + len,"%x" , reg); +debug ("Renaming cpu node %d %s to %s\n" , cpu_node, name, new_name); +fdt_set_name (fdt, offset, new_name); + } +if (callback) +callback (fdt, offset, cbarg); + +/* Structure may have changed, start at the beginning. */ + next_offset =0 ; + } + } + +return 0 ; +} + +#ifdef CONFIG_CMD_NET +static void octeon_set_one_fdt_mac (int node,uint64_t *mac) +{ +u8 mac_addr[6 ]; +int r; + + mac_addr[5 ] = *mac &0xff ; + mac_addr[4 ] = (*mac >>8 ) &0xff ; + mac_addr[3 ] = (*mac >>16 ) &0xff ; + mac_addr[2 ] = (*mac >>24 ) &0xff ; + mac_addr[1 ] = (*mac >>32 ) &0xff ; + mac_addr[0 ] = (*mac >>40 ) &0xff ; + + r =fdt_setprop_inplace (working_fdt, node,"local-mac-address" , mac_addr,6 ); +if (r ==0 ) + *mac = *mac +1 ; +} + +static uint64_t convert_mac (const u8 mac_addr[6 ]) +{ +int i; +u64 mac =0 ; + +for (i =0 ; i <6 ; i++) + mac = (mac <<8 ) | mac_addr[i]; +return mac; +} + +/** +* Fix up the MAC address in the flat device tree based on the MAC address +* stored in ethaddr or in the board descriptor. +* +* NOTE: This function is weak and an alias for __octeon_fixup_fdt_mac_addr. +*/ +void octeon_fixup_fdt_mac_addr (void ) __attribute__((weak,alias ("__octeon_fixup_fdt_mac_addr" ))); + +void __octeon_fixup_fdt_mac_addr (void ) +{ +int node, pip, interface, ethernet; +int i, e; +u64 mac =0 ; +uchar mac_addr[6 ]; +char name[20 ]; +bool env_mac_addr_valid; +const char *p; + +debug ("%s: env ethaddr: %s\n" , __func__, (p =env_get ("ethaddr" )) ? p :"not set" ); +if (eth_env_get_enetaddr ("ethaddr" , mac_addr)) { + mac =convert_mac (mac_addr); + env_mac_addr_valid = true; + }else { + mac =convert_mac ((uint8_t *)gd->arch.mac_desc.mac_addr_base); + env_mac_addr_valid = false; + } + +debug ("%s: mac_addr: %pM, board mac: %pM, env valid: %s\n" , __func__, mac_addr, + gd->arch.mac_desc.mac_addr_base, env_mac_addr_valid ?"true" :"false" ); + +if (env_mac_addr_valid &&memcmp (mac_addr, (void *)gd->arch.mac_desc.mac_addr_base,6 )) +printf ("Warning: the environment variable ethaddr is set to %pM\n" +"which does not match the board descriptor MAC address %pM.\n" +"Please clear the ethaddr environment variable with the command\n" +"\"setenv -f ethaddr; saveenv\" or change the board MAC address with the command\n" +"\"tlv_eeprom set mac %pM\" to change the board MAC address so that it matches\n" +"the environment address.\n" +"Note: the correct MAC address is usually the one stored in the tlv EEPROM.\n" , + mac_addr, gd->arch.mac_desc.mac_addr_base, mac_addr); + +for (i =0 ; i <2 ; i++) { +sprintf (name,"mix%x" , i); + p =fdt_get_alias (working_fdt, name); +if (p) { + node =fdt_path_offset (working_fdt, p); +if (node >0 ) +octeon_set_one_fdt_mac (node, &mac); + } + } + +for (i =0 ; i <2 ; i++) { +sprintf (name,"rgmii%x" , i); + p =fdt_get_alias (working_fdt, name); +if (p) { + node =fdt_path_offset (working_fdt, p); +if (node >0 ) +octeon_set_one_fdt_mac (node, &mac); + } + } + + pip =fdt_node_offset_by_compatible (working_fdt,-1 ,"cavium,octeon-3860-pip" ); + +if (pip >0 ) +for (i =0 ; i <8 ; i++) { +sprintf (name,"interface@%d" , i); + interface =fdt_subnode_offset (working_fdt, pip, name); +if (interface <=0 ) +continue ; +for (e =0 ; e <16 ; e++) { +sprintf (name,"ethernet@%d" , e); + ethernet =fdt_subnode_offset (working_fdt, interface, name); +if (ethernet <=0 ) +continue ; +octeon_set_one_fdt_mac (ethernet, &mac); + } + } + +/* Assign 78XX addresses in the order they appear in the device tree. */ + node =fdt_node_offset_by_compatible (working_fdt,-1 ,"cavium,octeon-7890-bgx-port" ); +while (node != -FDT_ERR_NOTFOUND ) { +octeon_set_one_fdt_mac (node, &mac); + node =fdt_node_offset_by_compatible (working_fdt, node, +"cavium,octeon-7890-bgx-port" ); + } +} +#endif + +/** +* This function fixes the clock-frequency in the flat device tree for the UART. +* +* NOTE: This function is weak and an alias for __octeon_fixup_fdt_uart. +*/ +void octeon_fixup_fdt_uart (void ) __attribute__((weak,alias ("__octeon_fixup_fdt_uart" ))); + +void __octeon_fixup_fdt_uart (void ) +{ +u32 clk; +int node; + + clk = gd->bus_clk; + +/* Device trees already have good values for fast simulator +* output, real boards need the correct value. +*/ + node =fdt_node_offset_by_compatible (working_fdt,-1 ,"cavium,octeon-3860-uart" ); +while (node != -FDT_ERR_NOTFOUND ) { +fdt_setprop_inplace_cell (working_fdt, node,"clock-frequency" , clk); + node =fdt_node_offset_by_compatible (working_fdt, node,"cavium,octeon-3860-uart" ); + } +} + +/** +* This function fills in the /memory portion of the flat device tree. +* +* NOTE: This function is weak and aliased to __octeon_fixup_fdt_memory. +*/ +void octeon_fixup_fdt_memory (void ) __attribute__((weak,alias ("__octeon_fixup_fdt_memory" ))); + +void __octeon_fixup_fdt_memory (void ) +{ +u64 sizes[3 ], addresses[3 ]; +u64 size_left = gd->ram_size; +int num_addresses =0 ; +int rc; +int node; + + size_left = gd->ram_size; + sizes[num_addresses] =min_t (u64, size_left,256 *1024 *1024 ); + size_left -= sizes[num_addresses]; + addresses[num_addresses] =0 ; + num_addresses++; + +if (size_left >0 ) { + sizes[num_addresses] = size_left; + addresses[num_addresses] =0x20000000ULL ; + num_addresses++; + } + + node =fdt_path_offset (working_fdt,"/memory" ); +if (node <0 ) + node =fdt_add_subnode (working_fdt,fdt_path_offset (working_fdt,"/" ),"memory" ); +if (node <0 ) { +printf ("Could not add memory section to fdt: %s\n" ,fdt_strerror (node)); +return ; + } + rc =fdt_fixup_memory_banks (working_fdt, addresses, sizes, num_addresses); +if (rc !=0 ) +printf ("%s: fdt_fixup_memory_banks returned %d when adding %d addresses\n" , + __func__, rc, num_addresses); +} + +void octeon_fixup_fdt (void ) __attribute__((weak,alias ("__octeon_fixup_fdt" ))); + +void __octeon_fixup_fdt (void ) +{ +if (!working_fdt) +return ; + +#ifdef CONFIG_CMD_NET +octeon_fixup_fdt_mac_addr (); +#endif /* CONFIG_CMD_NET */ + +#if !CONFIG_OCTEON_SIM_SPEED +octeon_fixup_fdt_uart (); +#endif + +octeon_fixup_fdt_memory (); +} + +int __board_fixup_fdt (void ) +{ +/* +* Nothing to do in this dummy implementation +*/ +return 0 ; +} + +int board_fixup_fdt (void ) __attribute__((weak,alias ("__board_fixup_fdt" ))); + +/** +* This is a helper function to find the offset of a PHY device given +* an Ethernet device. +* +* @param[in] eth - Ethernet device to search for PHY offset +* +* @returns offset of phy info in device tree or -1 if not found +*/ +//int octeon_fdt_find_phy(const struct eth_device *eth) +int octeon_fdt_find_phy (const struct udevice *eth) +{ +int aliases; +const void *fdt = gd->fdt_blob; +const char *pip_path; +int pip; +char buffer[64 ]; +#if 0 +struct octeon_eth_info *oct_eth_info = + (struct octeon_eth_info *)eth->priv; +#else +struct octeon_eth_info *oct_eth_info =dev_get_priv (eth); +#endif +int interface, index; +int phandle; +int phy; +u32 *phy_handle; + + aliases =fdt_path_offset (fdt,"/aliases" ); +if (aliases <0 ) { +puts ("/aliases not found in device tree!\n" ); +return -1 ; + } + pip_path =fdt_getprop (fdt, aliases,"pip" ,NULL ); +if (!pip_path) { +puts ("pip not found in aliases in device tree\n" ); +return -1 ; + } + pip =fdt_path_offset (fdt, pip_path); +if (pip <0 ) { +puts ("pip not found in device tree\n" ); +return -1 ; + } +snprintf (buffer,sizeof (buffer),"interface@%d" , oct_eth_info->interface); + interface =fdt_subnode_offset (fdt, pip, buffer); +if (interface <0 ) { +printf ("%s: interface@%d not found in device tree for %s\n" , __func__, + oct_eth_info->interface, eth->name); +return -1 ; + } +snprintf (buffer,sizeof (buffer),"ethernet@%x" , oct_eth_info->index); + index =fdt_subnode_offset (fdt, interface, buffer); +if (index <0 ) { +printf ("%s: ethernet@%x not found in device tree for %s\n" , __func__, + oct_eth_info->index, eth->name); +return -1 ; + } + phy_handle = (uint32_t *)fdt_getprop (fdt, index,"phy-handle" ,NULL ); +if (phy_handle <0 ) { +printf ("%s: phy-handle not found for %s\n" , __func__, eth->name); +return -1 ; + } + phandle =fdt32_to_cpu (*phy_handle); + phy =fdt_node_offset_by_phandle (fdt, phandle); +if (phy <0 ) { +printf ("%s: phy not found for %s\n" , __func__, eth->name); +return -1 ; + } + +return phy; +} + +/** +* This helper function returns if a node contains the specified vendor name. +* +* @param[in] fdt pointer to device tree blob +* @param nodeoffset offset of the tree node +* @param[in] vendor name of vendor to check +* +* returns: +* 0, if the node has a compatible vendor string property +* 1, if the node does not contain the vendor string property +* -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property +* -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag +* -FDT_ERR_BADMAGIC, +* -FDT_ERR_BADVERSION, +* -FDT_BADSTATE, +* -FDT_ERR_BADSTRUCTURE, standard meanings +*/ +int octeon_fdt_compat_vendor (const void *fdt,int nodeoffset,const char *vendor) +{ +const char *strlist; +const char *p; +int len; +int listlen; + + strlist =fdt_getprop (fdt, nodeoffset,"compatible" , &listlen); +if (!strlist) +return listlen; + + len =strlen (vendor); + +debug ("%s(%p, %d, %s (%p)) strlist: %s (%p), len: %d\n" , __func__, fdt, nodeoffset, vendor, + vendor, strlist, strlist, len); +while (listlen >= len) { +debug (" Comparing %d bytes of %s and %s\n" , len, vendor, strlist); +if ((memcmp (vendor, strlist, len) ==0 ) && + ((strlist[len] ==',' ) || (strlist[len] =='\0' ))) +return 0 ; + p =memchr (strlist,'\0' , listlen); +if (!p) +return 1 ;/* malformed strlist.. */ + listlen -= (p - strlist) +1 ; + strlist = p +1 ; + } +return 1 ; +} + +/** +* Given a node in the device tree get the OCTEON OCX node number +* +* @param fdt pointer to flat device tree +* @param nodeoffset node offset to get OCX node for +* +* @return the Octeon OCX node number +*/ +int octeon_fdt_get_soc_node (const void *fdt,int nodeoffset) +{ +return 0 ; +} + +/** +* Given a FDT node, check if it is compatible with a list of devices +* +* @param[in] fdt Flat device tree pointer +* @param node_offset Node offset in device tree +* @param[in] strlist Array of FDT devices to check, end must be NULL +* +* @return 0 if at least one device is compatible, 1 if not compatible. +*/ +int octeon_fdt_node_check_compatible (const void *fdt,int node_offset, +const char *const *strlist) +{ +while (*strlist && **strlist) { +debug ("%s: Checking %s\n" , __func__, *strlist); +if (!fdt_node_check_compatible (fdt, node_offset, *strlist)) { +debug ("%s: match found\n" , __func__); +return 0 ; + } + strlist++; + } +debug ("%s: No match found\n" , __func__); +return 1 ; +} + +/** +* Given a node offset, find the i2c bus number for that node +* +* @param[in] fdt Pointer to flat device tree +* @param node_offset Node offset in device tree +* +* @return i2c bus number or -1 if error +*/ +int octeon_fdt_i2c_get_bus (const void *fdt,int node_offset) +{ +const char *compat; +const u64 addresses[] = {0x1180000001000 ,0x1180000001200 }; +u64 reg; +int i; +int bus =-1 ; +bool found = false; + +if (octeon_has_feature (OCTEON_FEATURE_CIU3 )) + compat ="cavium,octeon-7890-twsi" ; +else + compat ="cavium,octeon-3860-twsi" ; + +while (node_offset >0 && + !(found = !fdt_node_check_compatible (fdt, node_offset, compat))) { + node_offset =fdt_parent_offset (fdt, node_offset); +#ifdef CONFIG_OCTEON_I2C_FDT + bus =i2c_get_bus_num_fdt (node_offset); +if (bus >=0 ) { +debug ("%s: Found bus 0x%x\n" , __func__, bus); +return bus; + } +#endif + } +if (!found) { +printf ("Error: node %d in device tree is not a child of the I2C bus\n" , + node_offset); +return -1 ; + } + + reg =fdtdec_get_addr (fdt, node_offset,"reg" ); +if (reg ==FDT_ADDR_T_NONE ) { +printf ("%s: Error: invalid reg address for TWSI bus\n" , __func__); +return -1 ; + } + +for (i =0 ; i <ARRAY_SIZE (addresses); i++) +if (reg == addresses[i]) { + bus = i; +break ; + } + +debug ("%s: bus 0x%x\n" , __func__, bus); +return bus; +} + +/** +* Given an offset into the fdt, output the i2c bus and address of the device +* +* @param[in] fdt fdt blob pointer +* @param node offset in FDT of device +* @param[out] bus i2c bus number of device +* @param[out] addr address of device on i2c bus +* +* @return 0 for success, -1 on error +*/ +int octeon_fdt_get_i2c_bus_addr (const void *fdt,int node,int *bus,int *addr) +{ + *bus =octeon_fdt_i2c_get_bus (fdt,fdt_parent_offset (fdt, node)); +if (*bus <0 ) { +printf ("%s: Could not get parent i2c bus\n" , __func__); +return -1 ; + } + *addr =fdtdec_get_int (fdt, node,"reg" ,-1 ); +if (*addr <0 ) +return -1 ; +return 0 ; +} + +/** +* Reads a GPIO pin given the node of the GPIO device in the device tree and +* the pin number. +* +* @param[in] fdt fdt blob pointer +* @param phandle phandle of GPIO node +* @param pin pin number to read +* +* @return 0 = pin is low, 1 = pin is high, -1 = error +*/ +int octeon_fdt_read_gpio (const void *fdt,int phandle,int pin) +{ +enum cvmx_gpio_type type; +__maybe_unused int node; +__maybe_unused int addr; +__maybe_unused int bus; +__maybe_unused int old_bus; +int num_pins; +int value; + + type =cvmx_fdt_get_gpio_type (fdt, phandle, &num_pins); +if ((pin &0xff ) >= num_pins) { +debug ("%s: pin number %d out of range\n" , __func__, pin); +return -1 ; + } +switch (type) { +#ifdef CONFIG_PCA953X +case CVMX_GPIO_PIN_PCA953X : + node =fdt_node_offset_by_phandle (fdt, phandle); +if (octeon_fdt_get_i2c_bus_addr (fdt, node, &bus, &addr)) { +printf ("%s: Could not get gpio bus and/or address\n" , __func__); +return -1 ; + } + value =pca953x_get_val (bus, addr); +if (value <0 ) { +printf ("%s: Error reading PCA953X GPIO@0x%x:0x%x\n" , __func__, bus, + addr); +return -1 ; + } + value = (value >> pin) &1 ; +break ; +#endif +#ifdef CONFIG_PCF857X +case CVMX_GPIO_PIN_PCF857X : + node =fdt_node_offset_by_phandle (fdt, phandle); +if (octeon_fdt_get_i2c_bus_addr (fdt, node, &bus, &addr)) { +printf ("%s: Could not get gpio bus and/or address\n" , __func__); +return -1 ; + } + value =pcf857x_get_val (bus, addr); +if (value <0 ) { +printf ("%s: Error reading PCF857X GPIO@0x%x:0x%x\n" , __func__, bus, + addr); +return -1 ; + } + value = (value >> pin) &1 ; +break ; +#endif +#ifdef CONFIG_PCA9698 +case CVMX_GPIO_PIN_PCA9698 : + node =fdt_node_offset_by_phandle (fdt, phandle); +if (octeon_fdt_get_i2c_bus_addr (fdt, node, &bus, &addr)) { +printf ("%s: Could not get gpio bus and/or address\n" , __func__); +return -1 ; + } + old_bus =i2c_get_bus_num (); +i2c_set_bus_num (bus); + value =pca9698_get_value (addr, pin); +i2c_set_bus_num (old_bus); +break ; +#endif +case CVMX_GPIO_PIN_OCTEON : + value =gpio_get_value (pin); +break ; +default : +printf ("%s: Unknown GPIO type %d\n" , __func__, type); +return -1 ; + } +return value; +} + +/** +* Reads a GPIO pin given the node of the GPIO device in the device tree and +* the pin number. +* +* @param[in] fdt fdt blob pointer +* @param phandle phandle of GPIO node +* @param pin pin number to read +* @param val value to write (1 = high, 0 = low) +* +* @return 0 = success, -1 = error +*/ +int octeon_fdt_set_gpio (const void *fdt,int phandle,int pin,int val) +{ +enum cvmx_gpio_type type; +int node; +int num_pins; +__maybe_unused int addr; +__maybe_unused int bus; +__maybe_unused int old_bus; +__maybe_unused int rc; + + node =fdt_node_offset_by_phandle (fdt, phandle); +if (node <0 ) { +printf ("%s: Invalid phandle\n" , __func__); +return -1 ; + } + + type =cvmx_fdt_get_gpio_type (fdt, phandle, &num_pins); +if ((pin &0xff ) >= num_pins) { +debug ("%s: pin number %d out of range\n" , __func__, pin); +return -1 ; + } +switch (type) { +#ifdef CONFIG_PCA953X +case CVMX_GPIO_PIN_PCA953X : +if (octeon_fdt_get_i2c_bus_addr (fdt, node, &bus, &addr)) { +printf ("%s: Could not get gpio bus and/or address\n" , __func__); +return -1 ; + } + +return pca953x_set_val (bus, addr,1 << pin, val << pin); +#endif +#ifdef CONFIG_PCF857X +case CVMX_GPIO_PIN_PCF857X : +if (octeon_fdt_get_i2c_bus_addr (fdt, node, &bus, &addr)) { +printf ("%s: Could not get gpio bus and/or address\n" , __func__); +return -1 ; + } +return pcf957x_set_val (bus, addr,1 << pin, val << pin); +#endif +#ifdef CONFIG_PCA9698 +case CVMX_GPIO_PIN_PCA9698 : +if (octeon_fdt_get_i2c_bus_addr (fdt, node, &bus, &addr)) { +printf ("%s: Could not get gpio bus and/or address\n" , __func__); +return -1 ; + } + old_bus =i2c_get_bus_num (); +i2c_set_bus_num (bus); + rc =pca9698_set_value (addr, pin, val); +i2c_set_bus_num (old_bus); +return rc; +#endif +case CVMX_GPIO_PIN_OCTEON : +return gpio_set_value (pin, val); +default : +printf ("%s: Unknown GPIO type %d\n" , __func__, type); +return -1 ; + } +} + +/** +* Given the node of a GPIO entry output the GPIO type, i2c bus and i2c +* address. +* +* @param fdt_node node of GPIO in device tree, generally +* derived from a phandle. +* @param[out] type Type of GPIO detected +* @param[out] i2c_bus For i2c GPIO expanders, the i2c bus number +* @param[out] i2c_addr For i2c GPIO expanders, the i2c address +* +* @return 0 for success, -1 for errors +* +* NOTE: It is up to the caller to determine the pin number. +*/ +int octeon_fdt_get_gpio_info (int fdt_node,enum octeon_gpio_type *type, +int *i2c_bus,int *i2c_addr) +{ +const void *fdt = gd->fdt_blob; + + int i2c_bus_node __attribute__((unused)); + + *type =GPIO_TYPE_UNKNOWN ; + +if (!octeon_fdt_node_check_compatible (fdt, fdt_node, octeon_gpio_list)) { +debug ("%s: Found Octeon compatible GPIO\n" , __func__); + *type =GPIO_TYPE_OCTEON ; +if (i2c_bus) + *i2c_bus =-1 ; +if (i2c_addr) + *i2c_addr =-1 ; +return 0 ; + } +#ifdef CONFIG_PCA9555 +if (!octeon_fdt_node_check_compatible (fdt, fdt_node, pca9555_gpio_list)) { +debug ("%s: Found PCA9555 type compatible GPIO\n" , __func__); + *type =GPIO_TYPE_PCA9555 ; + } +#endif +#ifdef CONFIG_PCA9554 +if (!octeon_fdt_node_check_compatible (fdt, fdt_node, pca9554_gpio_list)) { +debug ("%s: Found PCA9555 type compatible GPIO\n" , __func__); + *type =GPIO_TYPE_PCA9554 ; + } +#endif +#ifdef CONFIG_PCA953X +if (!octeon_fdt_node_check_compatible (fdt, fdt_node, pca953x_gpio_list)) { +debug ("%s: Found PCA953x compatible GPIO" , __func__); + *type =GPIO_TYPE_PCA953X ; + } +#endif +#ifdef CONFIG_PCA9698 +if (!octeon_fdt_node_check_compatible (fdt, fdt_node, pca9698_gpio_list)) { +debug ("%s: Found PCA9698 compatible GPIO" , __func__); + *type =GPIO_TYPE_PCA9698 ; + } +#endif +#if defined(CONFIG_PCA953X ) || defined(CONFIG_PCA9698 ) || \ + defined(CONFIG_PCA9555 ) || defined(CONFIG_PCA9554 ) +if (!i2c_addr || !i2c_bus) { +printf ("%s: Error: i2c_addr or i2c_bus is NULL\n" , __func__); +return -1 ; + } + + *i2c_addr =fdtdec_get_int (fdt, fdt_node,"reg" ,-1 ); + i2c_bus_node =fdt_parent_offset (fdt, fdt_node); +if (i2c_bus_node <0 ) { +printf ("%s: Invalid parent\n" , __func__); +return -1 ; + } + *i2c_bus =i2c_get_bus_num_fdt (i2c_bus_node); +#endif +return (*type !=GPIO_TYPE_UNKNOWN ) ?0 :-1 ; +} + +#ifdef CONFIG_PHY_VITESSE +/** +* Given a node in the flat device tree, return the matching PHY device +* +* @param fdt_node FDT node in device tree +* +* @return pointer to PHY device or NULL if none found. +*/ +static struct phy_device *octeon_fdt_get_phy_device_from_node (int fdt_node) +{ +struct eth_device *dev; +int i =0 ; +struct octeon_eth_info *ethinfo =NULL ; + +do { + dev =eth_get_dev_by_index (i++); +if (!dev) +return NULL ; + ethinfo = dev->priv; +if (ethinfo->phy_offset == fdt_node) +return ethinfo->phydev; + }while (dev); +return NULL ; +} +#endif + +/** +* Get the PHY data structure for the specified FDT node and output the type +* +* @param fdt_node FDT node of phy +* @param[out] type Type of GPIO +* +* @return pointer to phy device or NULL if no match found. +*/ +struct phy_device *octeon_fdt_get_phy_gpio_info (int fdt_node,enum octeon_gpio_type *type) +{ +#ifdef CONFIG_PHY_VITESSE +struct phy_device *phydev; + +if (!octeon_fdt_node_check_compatible (gd->fdt_blob, fdt_node, + vitesse_vsc8488_gpio_list)) { + phydev =octeon_fdt_get_phy_device_from_node (fdt_node); +if (phydev) { +debug ("%s: Found Vitesse VSC848X compatible GPIO\n" , __func__); + *type =GPIO_TYPE_VSC8488 ; +return phydev; + } + +debug ("%s: Error: phy device not found!\n" , __func__); +return NULL ; + } + +debug ("%s: No compatible Vitesse PHY type found\n" , __func__); +#endif +return NULL ; +}
Signature · 1 line
2.29.2
PATCH 44/50 mips: octeon: Add octeon_qlm.c
In reply to Stefan RoeseFrom: Aaron Williams <[email protected]>
Import octeon_qlm.c from 2013 U-Boot. It will be used by the later added drivers to support PCIe and networking on the MIPS Octeon II / III platforms.
---
arch/mips/mach-octeon/octeon_qlm.c | 5853 ++++++++++++++++++++++++++++ 1 file changed, 5853 insertions(+) create mode 100644 arch/mips/mach-octeon/octeon_qlm.c
arch/mips/mach-octeon/octeon_qlm.c new file +5853 -0
@@ -0,0 +1,5853 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Marvell International Ltd. +*/ + +#include <dm.h> +#include <time.h> +#include <linux/delay.h> + +#include <mach/cvmx-regs.h> +#include <mach/octeon-model.h> +#include <mach/cvmx-fuse.h> +#include <mach/cvmx-qlm.h> +#include <mach/octeon_qlm.h> +#include <mach/cvmx-pcie.h> + +#include <mach/cvmx-bgxx-defs.h> +#include <mach/cvmx-ciu-defs.h> +#include <mach/cvmx-gmxx-defs.h> +#include <mach/cvmx-gserx-defs.h> +#include <mach/cvmx-mio-defs.h> +#include <mach/cvmx-pciercx-defs.h> +#include <mach/cvmx-pemx-defs.h> +#include <mach/cvmx-pexp-defs.h> +#include <mach/cvmx-rst-defs.h> +#include <mach/cvmx-sata-defs.h> +#include <mach/cvmx-sli-defs.h> +#include <mach/cvmx-sriomaintx-defs.h> +#include <mach/cvmx-sriox-defs.h> + +DECLARE_GLOBAL_DATA_PTR ; + +/** 2.5GHz with 100MHz reference clock */ +#define R_2_5G_REFCLK100 0x0 +/** 5.0GHz with 100MHz reference clock */ +#define R_5G_REFCLK100 0x1 +/** 8.0GHz with 100MHz reference clock */ +#define R_8G_REFCLK100 0x2 +/** 1.25GHz with 156.25MHz reference clock */ +#define R_125G_REFCLK15625_KX 0x3 +/** 3.125Ghz with 156.25MHz reference clock (XAUI) */ +#define R_3125G_REFCLK15625_XAUI 0x4 +/** 10.3125GHz with 156.25MHz reference clock (XFI/XLAUI) */ +#define R_103125G_REFCLK15625_KR 0x5 +/** 1.25GHz with 156.25MHz reference clock (SGMII) */ +#define R_125G_REFCLK15625_SGMII 0x6 +/** 5GHz with 156.25MHz reference clock (QSGMII) */ +#define R_5G_REFCLK15625_QSGMII 0x7 +/** 6.25GHz with 156.25MHz reference clock (RXAUI/25G) */ +#define R_625G_REFCLK15625_RXAUI 0x8 +/** 2.5GHz with 125MHz reference clock */ +#define R_2_5G_REFCLK125 0x9 +/** 5GHz with 125MHz reference clock */ +#define R_5G_REFCLK125 0xa +/** 8GHz with 125MHz reference clock */ +#define R_8G_REFCLK125 0xb +/** Must be last, number of modes */ +#define R_NUM_LANE_MODES 0xc + +int cvmx_qlm_is_ref_clock (int qlm,int reference_mhz) +{ +int ref_clock =cvmx_qlm_measure_clock (qlm); +int mhz = ref_clock /1000000 ; +int range = reference_mhz /10 ; + +return ((mhz >= reference_mhz - range) && (mhz <= reference_mhz + range)); +} + +static int __get_qlm_spd (int qlm,int speed) +{ +int qlm_spd =0xf ; + +if (cvmx_qlm_is_ref_clock (qlm,100 )) { +if (speed ==1250 ) + qlm_spd =0x3 ; +else if (speed ==2500 ) + qlm_spd =0x2 ; +else if (speed ==5000 ) + qlm_spd =0x0 ; +else + qlm_spd =0xf ; + }else if (cvmx_qlm_is_ref_clock (qlm,125 )) { +if (speed ==1250 ) + qlm_spd =0xa ; +else if (speed ==2500 ) + qlm_spd =0x9 ; +else if (speed ==3125 ) + qlm_spd =0x8 ; +else if (speed ==5000 ) + qlm_spd =0x6 ; +else if (speed ==6250 ) + qlm_spd =0x5 ; +else + qlm_spd =0xf ; + }else if (cvmx_qlm_is_ref_clock (qlm,156 )) { +if (speed ==1250 ) + qlm_spd =0x4 ; +else if (speed ==2500 ) + qlm_spd =0x7 ; +else if (speed ==3125 ) + qlm_spd =0xe ; +else if (speed ==3750 ) + qlm_spd =0xd ; +else if (speed ==5000 ) + qlm_spd =0xb ; +else if (speed ==6250 ) + qlm_spd =0xc ; +else + qlm_spd =0xf ; + }else if (cvmx_qlm_is_ref_clock (qlm,161 )) { +if (speed ==6316 ) + qlm_spd =0xc ; + } +return qlm_spd; +} + +static void __set_qlm_pcie_mode_61xx (int pcie_port,int root_complex) +{ +int rc = root_complex ?1 :0 ; +int ep = root_complex ?0 :1 ; +cvmx_ciu_soft_prst1_t soft_prst1; +cvmx_ciu_soft_prst_t soft_prst; +cvmx_mio_rst_ctlx_t rst_ctl; + +if (pcie_port) { + soft_prst1.u64 =csr_rd (CVMX_CIU_SOFT_PRST1 ); + soft_prst1.s.soft_prst =1 ; +csr_wr (CVMX_CIU_SOFT_PRST1 , soft_prst1.u64); + }else { + soft_prst.u64 =csr_rd (CVMX_CIU_SOFT_PRST ); + soft_prst.s.soft_prst =1 ; +csr_wr (CVMX_CIU_SOFT_PRST , soft_prst.u64); + } + + rst_ctl.u64 =csr_rd (CVMX_MIO_RST_CTLX (pcie_port)); + + rst_ctl.s.prst_link = rc; + rst_ctl.s.rst_link = ep; + rst_ctl.s.prtmode = rc; + rst_ctl.s.rst_drv = rc; + rst_ctl.s.rst_rcv =0 ; + rst_ctl.s.rst_chip = ep; +csr_wr (CVMX_MIO_RST_CTLX (pcie_port), rst_ctl.u64); + +if (root_complex ==0 ) { +if (pcie_port) { + soft_prst1.u64 =csr_rd (CVMX_CIU_SOFT_PRST1 ); + soft_prst1.s.soft_prst =0 ; +csr_wr (CVMX_CIU_SOFT_PRST1 , soft_prst1.u64); + }else { + soft_prst.u64 =csr_rd (CVMX_CIU_SOFT_PRST ); + soft_prst.s.soft_prst =0 ; +csr_wr (CVMX_CIU_SOFT_PRST , soft_prst.u64); + } + } +} + +/** +* Configure qlm speed and mode. MIO_QLMX_CFG[speed,mode] are not set +* for CN61XX. +* +* @param qlm The QLM to configure +* @param speed The speed the QLM needs to be configured in Mhz. +* @param mode The QLM to be configured as SGMII/XAUI/PCIe. +* QLM 0: 0 = PCIe0 1X4, 1 = Reserved, 2 = SGMII1, 3 = XAUI1 +* QLM 1: 0 = PCIe1 1x2, 1 = PCIe(0/1) 2x1, 2 - 3 = Reserved +* QLM 2: 0 - 1 = Reserved, 2 = SGMII0, 3 = XAUI0 +* @param rc Only used for PCIe, rc = 1 for root complex mode, 0 for EP +* mode. +* @param pcie2x1 Only used when QLM1 is in PCIE2x1 mode. The QLM_SPD has a +* different value on how PEMx needs to be configured: +* 0x0 - both PEM0 & PEM1 are in gen1 mode. +* 0x1 - PEM0 in gen2 and PEM1 in gen1 mode. +* 0x2 - PEM0 in gen1 and PEM1 in gen2 mode. +* 0x3 - both PEM0 & PEM1 are in gen2 mode. +* SPEED value is ignored in this mode. QLM_SPD is set based on +* pcie2x1 value in this mode. +* +* @return Return 0 on success or -1. +*/ +static int octeon_configure_qlm_cn61xx (int qlm,int speed,int mode,int rc,int pcie2x1) +{ +cvmx_mio_qlmx_cfg_t qlm_cfg; + +/* The QLM speed varies for SGMII/XAUI and PCIe mode. And depends on +* reference clock. +*/ +if (!OCTEON_IS_MODEL (OCTEON_CN61XX )) +return -1 ; + +if (qlm <3 ) { + qlm_cfg.u64 =csr_rd (CVMX_MIO_QLMX_CFG (qlm)); + }else { +debug ("WARNING: Invalid QLM(%d) passed\n" , qlm); +return -1 ; + } + +switch (qlm) { +/* SGMII/XAUI mode */ +case 2 : { +if (mode <2 ) { + qlm_cfg.s.qlm_spd =0xf ; +break ; + } + qlm_cfg.s.qlm_spd =__get_qlm_spd (qlm, speed); + qlm_cfg.s.qlm_cfg = mode; +break ; + } +case 1 : { +if (mode ==1 ) {/* 2x1 mode */ +cvmx_mio_qlmx_cfg_t qlm0; + +/* When QLM0 is configured as PCIe(QLM_CFG=0x0) +* and enabled (QLM_SPD != 0xf), QLM1 cannot be +* configured as PCIe 2x1 mode (QLM_CFG=0x1) +* and enabled (QLM_SPD != 0xf). +*/ + qlm0.u64 =csr_rd (CVMX_MIO_QLMX_CFG (0 )); +if (qlm0.s.qlm_spd !=0xf && qlm0.s.qlm_cfg ==0 ) { +debug ("Invalid mode(%d) for QLM(%d) as QLM1 is PCIe mode\n" , + mode, qlm); + qlm_cfg.s.qlm_spd =0xf ; +break ; + } + +/* Set QLM_SPD based on reference clock and mode */ +if (cvmx_qlm_is_ref_clock (qlm,100 )) { +if (pcie2x1 ==0x3 ) + qlm_cfg.s.qlm_spd =0x0 ; +else if (pcie2x1 ==0x1 ) + qlm_cfg.s.qlm_spd =0x2 ; +else if (pcie2x1 ==0x2 ) + qlm_cfg.s.qlm_spd =0x1 ; +else if (pcie2x1 ==0x0 ) + qlm_cfg.s.qlm_spd =0x3 ; +else + qlm_cfg.s.qlm_spd =0xf ; + }else if (cvmx_qlm_is_ref_clock (qlm,125 )) { +if (pcie2x1 ==0x3 ) + qlm_cfg.s.qlm_spd =0x4 ; +else if (pcie2x1 ==0x1 ) + qlm_cfg.s.qlm_spd =0x6 ; +else if (pcie2x1 ==0x2 ) + qlm_cfg.s.qlm_spd =0x9 ; +else if (pcie2x1 ==0x0 ) + qlm_cfg.s.qlm_spd =0x7 ; +else + qlm_cfg.s.qlm_spd =0xf ; + } + qlm_cfg.s.qlm_cfg = mode; +csr_wr (CVMX_MIO_QLMX_CFG (qlm), qlm_cfg.u64); + +/* Set PCIe mode bits */ +__set_qlm_pcie_mode_61xx (0 , rc); +__set_qlm_pcie_mode_61xx (1 , rc); +return 0 ; + }else if (mode >1 ) { +debug ("Invalid mode(%d) for QLM(%d).\n" , mode, qlm); + qlm_cfg.s.qlm_spd =0xf ; +break ; + } + +/* Set speed and mode for PCIe 1x2 mode. */ +if (cvmx_qlm_is_ref_clock (qlm,100 )) { +if (speed ==5000 ) + qlm_cfg.s.qlm_spd =0x1 ; +else if (speed ==2500 ) + qlm_cfg.s.qlm_spd =0x2 ; +else + qlm_cfg.s.qlm_spd =0xf ; + }else if (cvmx_qlm_is_ref_clock (qlm,125 )) { +if (speed ==5000 ) + qlm_cfg.s.qlm_spd =0x4 ; +else if (speed ==2500 ) + qlm_cfg.s.qlm_spd =0x6 ; +else + qlm_cfg.s.qlm_spd =0xf ; + }else { + qlm_cfg.s.qlm_spd =0xf ; + } + + qlm_cfg.s.qlm_cfg = mode; +csr_wr (CVMX_MIO_QLMX_CFG (qlm), qlm_cfg.u64); + +/* Set PCIe mode bits */ +__set_qlm_pcie_mode_61xx (1 , rc); +return 0 ; + } +case 0 : { +/* QLM_CFG = 0x1 - Reserved */ +if (mode ==1 ) { + qlm_cfg.s.qlm_spd =0xf ; +break ; + } +/* QLM_CFG = 0x0 - PCIe 1x4(PEM0) */ +if (mode ==0 && speed !=5000 && speed !=2500 ) { + qlm_cfg.s.qlm_spd =0xf ; +break ; + } + +/* Set speed and mode */ + qlm_cfg.s.qlm_spd =__get_qlm_spd (qlm, speed); + qlm_cfg.s.qlm_cfg = mode; +csr_wr (CVMX_MIO_QLMX_CFG (qlm), qlm_cfg.u64); + +/* Set PCIe mode bits */ +if (mode ==0 ) +__set_qlm_pcie_mode_61xx (0 , rc); + +return 0 ; + } +default : +debug ("WARNING: Invalid QLM(%d) passed\n" , qlm); + qlm_cfg.s.qlm_spd =0xf ; + } +csr_wr (CVMX_MIO_QLMX_CFG (qlm), qlm_cfg.u64); +return 0 ; +} + +/* qlm : DLM to configure +* baud_mhz : speed of the DLM +* ref_clk_sel : reference clock speed selection where: +* 0: 100MHz +* 1: 125MHz +* 2: 156.25MHz +* +* ref_clk_input: reference clock input where: +* 0: DLMC_REF_CLK0_[P,N] +* 1: DLMC_REF_CLK1_[P,N] +* 2: DLM0_REF_CLK_[P,N] (only valid for QLM 0) +* is_sff7000_rxaui : boolean to indicate whether qlm is RXAUI on SFF7000 +*/ +static int __dlm_setup_pll_cn70xx (int qlm,int baud_mhz,int ref_clk_sel,int ref_clk_input, +int is_sff7000_rxaui) +{ +cvmx_gserx_dlmx_test_powerdown_t dlmx_test_powerdown; +cvmx_gserx_dlmx_ref_ssp_en_t dlmx_ref_ssp_en; +cvmx_gserx_dlmx_mpll_en_t dlmx_mpll_en; +cvmx_gserx_dlmx_phy_reset_t dlmx_phy_reset; +cvmx_gserx_dlmx_tx_amplitude_t tx_amplitude; +cvmx_gserx_dlmx_tx_preemph_t tx_preemph; +cvmx_gserx_dlmx_rx_eq_t rx_eq; +cvmx_gserx_dlmx_ref_clkdiv2_t ref_clkdiv2; +cvmx_gserx_dlmx_mpll_multiplier_t mpll_multiplier; +int gmx_ref_clk =100 ; + +debug ("%s(%d, %d, %d, %d, %d)\n" , __func__, qlm, baud_mhz, ref_clk_sel, ref_clk_input, + is_sff7000_rxaui); +if (ref_clk_sel ==1 ) + gmx_ref_clk =125 ; +else if (ref_clk_sel ==2 ) + gmx_ref_clk =156 ; + +if (qlm !=0 && ref_clk_input ==2 ) { +printf ("%s: Error: can only use reference clock inputs 0 or 1 for DLM %d\n" , + __func__, qlm); +return -1 ; + } + +/* Hardware defaults are invalid */ + tx_amplitude.u64 =csr_rd (CVMX_GSERX_DLMX_TX_AMPLITUDE (qlm,0 )); +if (is_sff7000_rxaui) { + tx_amplitude.s.tx0_amplitude =100 ; + tx_amplitude.s.tx1_amplitude =100 ; + }else { + tx_amplitude.s.tx0_amplitude =65 ; + tx_amplitude.s.tx1_amplitude =65 ; + } + +csr_wr (CVMX_GSERX_DLMX_TX_AMPLITUDE (qlm,0 ), tx_amplitude.u64); + + tx_preemph.u64 =csr_rd (CVMX_GSERX_DLMX_TX_PREEMPH (qlm,0 )); + +if (is_sff7000_rxaui) { + tx_preemph.s.tx0_preemph =0 ; + tx_preemph.s.tx1_preemph =0 ; + }else { + tx_preemph.s.tx0_preemph =22 ; + tx_preemph.s.tx1_preemph =22 ; + } +csr_wr (CVMX_GSERX_DLMX_TX_PREEMPH (qlm,0 ), tx_preemph.u64); + + rx_eq.u64 =csr_rd (CVMX_GSERX_DLMX_RX_EQ (qlm,0 )); + rx_eq.s.rx0_eq =0 ; + rx_eq.s.rx1_eq =0 ; +csr_wr (CVMX_GSERX_DLMX_RX_EQ (qlm,0 ), rx_eq.u64); + +/* 1. Write GSER0_DLM0_REF_USE_PAD[REF_USE_PAD] = 1 (to select +* reference-clock input) +* The documentation for this register in the HRM is useless since +* it says it selects between two different clocks that are not +* documented anywhere. What it really does is select between +* DLM0_REF_CLK_[P,N] if 1 and DLMC_REF_CLK[0,1]_[P,N] if 0. +* +* This register must be 0 for DLMs 1 and 2 and can only be 1 for +* DLM 0. +*/ +csr_wr (CVMX_GSERX_DLMX_REF_USE_PAD (0 ,0 ), ((ref_clk_input ==2 ) && (qlm ==0 )) ?1 :0 ); + +/* Reference clock was already chosen before we got here */ + +/* 2. Write GSER0_DLM0_REFCLK_SEL[REFCLK_SEL] if required for +* reference-clock selection. +* +* If GSERX_DLMX_REF_USE_PAD is 1 then this register is ignored. +*/ +csr_wr (CVMX_GSERX_DLMX_REFCLK_SEL (0 ,0 ), ref_clk_input &1 ); + +/* Reference clock was already chosen before we got here */ + +/* 3. If required, write GSER0_DLM0_REF_CLKDIV2[REF_CLKDIV2] (must be +* set if reference clock > 100 MHz) +*/ +/* Apply workaround for Errata (G-20669) MPLL may not come up. */ + ref_clkdiv2.u64 =csr_rd (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 )); +if (gmx_ref_clk ==100 ) + ref_clkdiv2.s.ref_clkdiv2 =0 ; +else + ref_clkdiv2.s.ref_clkdiv2 =1 ; +csr_wr (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 ), ref_clkdiv2.u64); + +/* 1. Ensure GSER(0)_DLM(0..2)_PHY_RESET[PHY_RESET] is set. */ + dlmx_phy_reset.u64 =csr_rd (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 )); + dlmx_phy_reset.s.phy_reset =1 ; +csr_wr (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 ), dlmx_phy_reset.u64); + +/* 2. If SGMII or QSGMII or RXAUI (i.e. if DLM0) set +* GSER(0)_DLM(0)_MPLL_EN[MPLL_EN] to one. +*/ +/* 7. Set GSER0_DLM0_MPLL_EN[MPLL_EN] = 1 */ + dlmx_mpll_en.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_EN (0 ,0 )); + dlmx_mpll_en.s.mpll_en =1 ; +csr_wr (CVMX_GSERX_DLMX_MPLL_EN (0 ,0 ), dlmx_mpll_en.u64); + +/* 3. Set GSER(0)_DLM(0..2)_MPLL_MULTIPLIER[MPLL_MULTIPLIER] +* to the value in the preceding table, which is different +* than the desired setting prescribed by the HRM. +*/ + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); +if (gmx_ref_clk ==100 ) + mpll_multiplier.s.mpll_multiplier =35 ; +else if (gmx_ref_clk ==125 ) + mpll_multiplier.s.mpll_multiplier =56 ; +else + mpll_multiplier.s.mpll_multiplier =45 ; +debug ("%s: Setting mpll multiplier to %u for DLM%d, baud %d, clock rate %uMHz\n" , + __func__, mpll_multiplier.s.mpll_multiplier, qlm, baud_mhz, gmx_ref_clk); + +csr_wr (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 ), mpll_multiplier.u64); + +/* 5. Clear GSER0_DLM0_TEST_POWERDOWN[TEST_POWERDOWN] */ + dlmx_test_powerdown.u64 =csr_rd (CVMX_GSERX_DLMX_TEST_POWERDOWN (qlm,0 )); + dlmx_test_powerdown.s.test_powerdown =0 ; +csr_wr (CVMX_GSERX_DLMX_TEST_POWERDOWN (qlm,0 ), dlmx_test_powerdown.u64); + +/* 6. Set GSER0_DLM0_REF_SSP_EN[REF_SSP_EN] = 1 */ + dlmx_ref_ssp_en.u64 =csr_rd (CVMX_GSERX_DLMX_REF_SSP_EN (qlm,0 )); + dlmx_ref_ssp_en.s.ref_ssp_en =1 ; +csr_wr (CVMX_GSERX_DLMX_REF_SSP_EN (0 ,0 ), dlmx_ref_ssp_en.u64); + +/* 8. Clear GSER0_DLM0_PHY_RESET[PHY_RESET] = 0 */ + dlmx_phy_reset.u64 =csr_rd (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 )); + dlmx_phy_reset.s.phy_reset =0 ; +csr_wr (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 ), dlmx_phy_reset.u64); + +/* 5. If PCIe or SATA (i.e. if DLM1 or DLM2), set both MPLL_EN +* and MPLL_EN_OVRD to one in GSER(0)_PHY(1..2)_OVRD_IN_LO. +*/ + +/* 6. Decrease MPLL_MULTIPLIER by one continually until it +* reaches the desired long-term setting, ensuring that each +* MPLL_MULTIPLIER value is constant for at least 1 msec before +* changing to the next value. The desired long-term setting is +* as indicated in HRM tables 21-1, 21-2, and 21-3. This is not +* required with the HRM sequence. +*/ + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); +__cvmx_qlm_set_mult (qlm, baud_mhz, mpll_multiplier.s.mpll_multiplier); + +/* 9. Poll until the MPLL locks. Wait for +* GSER0_DLM0_MPLL_STATUS[MPLL_STATUS] = 1 +*/ +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_MPLL_STATUS (qlm,0 ), + cvmx_gserx_dlmx_mpll_status_t, mpll_status, ==, 1, 10000)) { +printf ("PLL for DLM%d failed to lock\n" , qlm); +return -1 ; + } +return 0 ; +} + +static int __dlm0_setup_tx_cn70xx (int speed,int ref_clk_sel) +{ +int need0, need1; +cvmx_gmxx_inf_mode_t mode0, mode1; +cvmx_gserx_dlmx_tx_rate_t rate; +cvmx_gserx_dlmx_tx_en_t en; +cvmx_gserx_dlmx_tx_cm_en_t cm_en; +cvmx_gserx_dlmx_tx_data_en_t data_en; +cvmx_gserx_dlmx_tx_reset_t tx_reset; + +debug ("%s(%d, %d)\n" , __func__, speed, ref_clk_sel); + mode0.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); + mode1.u64 =csr_rd (CVMX_GMXX_INF_MODE (1 )); + +/* Which lanes do we need? */ + need0 = (mode0.s.mode !=CVMX_GMX_INF_MODE_DISABLED ); + need1 = (mode1.s.mode !=CVMX_GMX_INF_MODE_DISABLED ) || + (mode0.s.mode ==CVMX_GMX_INF_MODE_RXAUI ); + +/* 1. Write GSER0_DLM0_TX_RATE[TXn_RATE] (Set according to required +* data rate (see Table 21-1). +*/ + rate.u64 =csr_rd (CVMX_GSERX_DLMX_TX_RATE (0 ,0 )); +debug ("%s: speed: %d\n" , __func__, speed); +switch (speed) { +case 1250 : +case 2500 : +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_100MHZ :/* 100MHz */ +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.tx0_rate = (mode0.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?2 :0 ; + rate.s.tx1_rate = (mode1.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?2 :0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +case 3125 : +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.tx0_rate = (mode0.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?1 :0 ; + rate.s.tx1_rate = (mode1.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?1 :0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +case 5000 :/* QSGMII only */ +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_100MHZ :/* 100MHz */ + rate.s.tx0_rate =0 ; + rate.s.tx1_rate =0 ; +break ; +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.tx0_rate =0 ; + rate.s.tx1_rate =0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +case 6250 : +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.tx0_rate =0 ; + rate.s.tx1_rate =0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +default : +printf ("%s: Invalid rate %d\n" , __func__, speed); +return -1 ; + } +debug ("%s: tx 0 rate: %d, tx 1 rate: %d\n" , __func__, rate.s.tx0_rate, rate.s.tx1_rate); +csr_wr (CVMX_GSERX_DLMX_TX_RATE (0 ,0 ), rate.u64); + +/* 2. Set GSER0_DLM0_TX_EN[TXn_EN] = 1 */ + en.u64 =csr_rd (CVMX_GSERX_DLMX_TX_EN (0 ,0 )); + en.s.tx0_en = need0; + en.s.tx1_en = need1; +csr_wr (CVMX_GSERX_DLMX_TX_EN (0 ,0 ), en.u64); + +/* 3 set GSER0_DLM0_TX_CM_EN[TXn_CM_EN] = 1 */ + cm_en.u64 =csr_rd (CVMX_GSERX_DLMX_TX_CM_EN (0 ,0 )); + cm_en.s.tx0_cm_en = need0; + cm_en.s.tx1_cm_en = need1; +csr_wr (CVMX_GSERX_DLMX_TX_CM_EN (0 ,0 ), cm_en.u64); + +/* 4. Set GSER0_DLM0_TX_DATA_EN[TXn_DATA_EN] = 1 */ + data_en.u64 =csr_rd (CVMX_GSERX_DLMX_TX_DATA_EN (0 ,0 )); + data_en.s.tx0_data_en = need0; + data_en.s.tx1_data_en = need1; +csr_wr (CVMX_GSERX_DLMX_TX_DATA_EN (0 ,0 ), data_en.u64); + +/* 5. Clear GSER0_DLM0_TX_RESET[TXn_DATA_EN] = 0 */ + tx_reset.u64 =csr_rd (CVMX_GSERX_DLMX_TX_RESET (0 ,0 )); + tx_reset.s.tx0_reset = !need0; + tx_reset.s.tx1_reset = !need1; +csr_wr (CVMX_GSERX_DLMX_TX_RESET (0 ,0 ), tx_reset.u64); + +/* 6. Poll GSER0_DLM0_TX_STATUS[TXn_STATUS, TXn_CM_STATUS] until both +* are set to 1. This prevents GMX from transmitting until the DLM +* is ready. +*/ +if (need0) { +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_TX_STATUS (0 ,0 ), + cvmx_gserx_dlmx_tx_status_t, tx0_status, ==, 1, 10000)) { +printf ("DLM0 TX0 status fail\n" ); +return -1 ; + } +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_TX_STATUS (0 ,0 ), + cvmx_gserx_dlmx_tx_status_t, tx0_cm_status, ==, 1, +10000 )) { +printf ("DLM0 TX0 CM status fail\n" ); +return -1 ; + } + } +if (need1) { +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_TX_STATUS (0 ,0 ), + cvmx_gserx_dlmx_tx_status_t, tx1_status, ==, 1, 10000)) { +printf ("DLM0 TX1 status fail\n" ); +return -1 ; + } +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_TX_STATUS (0 ,0 ), + cvmx_gserx_dlmx_tx_status_t, tx1_cm_status, ==, 1, +10000 )) { +printf ("DLM0 TX1 CM status fail\n" ); +return -1 ; + } + } +return 0 ; +} + +static int __dlm0_setup_rx_cn70xx (int speed,int ref_clk_sel) +{ +int need0, need1; +cvmx_gmxx_inf_mode_t mode0, mode1; +cvmx_gserx_dlmx_rx_rate_t rate; +cvmx_gserx_dlmx_rx_pll_en_t pll_en; +cvmx_gserx_dlmx_rx_data_en_t data_en; +cvmx_gserx_dlmx_rx_reset_t rx_reset; + +debug ("%s(%d, %d)\n" , __func__, speed, ref_clk_sel); + mode0.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); + mode1.u64 =csr_rd (CVMX_GMXX_INF_MODE (1 )); + +/* Which lanes do we need? */ + need0 = (mode0.s.mode !=CVMX_GMX_INF_MODE_DISABLED ); + need1 = (mode1.s.mode !=CVMX_GMX_INF_MODE_DISABLED ) || + (mode0.s.mode ==CVMX_GMX_INF_MODE_RXAUI ); + +/* 1. Write GSER0_DLM0_RX_RATE[RXn_RATE] (must match the +* GER0_DLM0_TX_RATE[TXn_RATE] setting). +*/ + rate.u64 =csr_rd (CVMX_GSERX_DLMX_RX_RATE (0 ,0 )); +switch (speed) { +case 1250 : +case 2500 : +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_100MHZ :/* 100MHz */ +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.rx0_rate = (mode0.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?2 :0 ; + rate.s.rx1_rate = (mode1.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?2 :0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +case 3125 : +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.rx0_rate = (mode0.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?1 :0 ; + rate.s.rx1_rate = (mode1.s.mode ==CVMX_GMX_INF_MODE_SGMII ) ?1 :0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +case 5000 :/* QSGMII only */ +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_100MHZ :/* 100MHz */ +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.rx0_rate =0 ; + rate.s.rx1_rate =0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +case 6250 : +switch (ref_clk_sel) { +case OCTEON_QLM_REF_CLK_125MHZ :/* 125MHz */ +case OCTEON_QLM_REF_CLK_156MHZ :/* 156.25MHz */ + rate.s.rx0_rate =0 ; + rate.s.rx1_rate =0 ; +break ; +default : +printf ("Invalid reference clock select %d\n" , ref_clk_sel); +return -1 ; + } +break ; +default : +printf ("%s: Invalid rate %d\n" , __func__, speed); +return -1 ; + } +debug ("%s: rx 0 rate: %d, rx 1 rate: %d\n" , __func__, rate.s.rx0_rate, rate.s.rx1_rate); +csr_wr (CVMX_GSERX_DLMX_RX_RATE (0 ,0 ), rate.u64); + +/* 2. Set GSER0_DLM0_RX_PLL_EN[RXn_PLL_EN] = 1 */ + pll_en.u64 =csr_rd (CVMX_GSERX_DLMX_RX_PLL_EN (0 ,0 )); + pll_en.s.rx0_pll_en = need0; + pll_en.s.rx1_pll_en = need1; +csr_wr (CVMX_GSERX_DLMX_RX_PLL_EN (0 ,0 ), pll_en.u64); + +/* 3. Set GSER0_DLM0_RX_DATA_EN[RXn_DATA_EN] = 1 */ + data_en.u64 =csr_rd (CVMX_GSERX_DLMX_RX_DATA_EN (0 ,0 )); + data_en.s.rx0_data_en = need0; + data_en.s.rx1_data_en = need1; +csr_wr (CVMX_GSERX_DLMX_RX_DATA_EN (0 ,0 ), data_en.u64); + +/* 4. Clear GSER0_DLM0_RX_RESET[RXn_DATA_EN] = 0. Now the GMX can be +* enabled: set GMX(0..1)_INF_MODE[EN] = 1 +*/ + rx_reset.u64 =csr_rd (CVMX_GSERX_DLMX_RX_RESET (0 ,0 )); + rx_reset.s.rx0_reset = !need0; + rx_reset.s.rx1_reset = !need1; +csr_wr (CVMX_GSERX_DLMX_RX_RESET (0 ,0 ), rx_reset.u64); + +return 0 ; +} + +static int a_clk; + +static int __dlm2_sata_uctl_init_cn70xx (void ) +{ +cvmx_sata_uctl_ctl_t uctl_ctl; +const int MAX_A_CLK =333000000 ;/* Max of 333Mhz */ +int divisor, a_clkdiv; + +/* Wait for all voltages to reach a stable stable. Ensure the +* reference clock is up and stable. +*/ + +/* 2. Wait for IOI reset to deassert. */ + +/* 3. Optionally program the GPIO CSRs for SATA features. +* a. For cold-presence detect: +* i. Select a GPIO for the input and program GPIO_SATA_CTL[sel] +* for port0 and port1. +* ii. Select a GPIO for the output and program +* GPIO_BIT_CFG*[OUTPUT_SEL] for port0 and port1. +* b. For mechanical-presence detect, select a GPIO for the input +* and program GPIO_SATA_CTL[SEL] for port0/port1. +* c. For LED activity, select a GPIO for the output and program +* GPIO_BIT_CFG*[OUTPUT_SEL] for port0/port1. +*/ + +/* 4. Assert all resets: +* a. UAHC reset: SATA_UCTL_CTL[UAHC_RST] = 1 +* a. UCTL reset: SATA_UCTL_CTL[UCTL_RST] = 1 +*/ + + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.sata_uahc_rst =1 ; + uctl_ctl.s.sata_uctl_rst =1 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +/* 5. Configure the ACLK: +* a. Reset the clock dividers: SATA_UCTL_CTL[A_CLKDIV_RST] = 1. +* b. Select the ACLK frequency (400 MHz maximum) +* i. SATA_UCTL_CTL[A_CLKDIV] = desired value, +* ii. SATA_UCTL_CTL[A_CLKDIV_EN] = 1 to enable the ACLK, +* c. Deassert the ACLK clock divider reset: +* SATA_UCTL_CTL[A_CLKDIV_RST] = 0 +*/ + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.a_clkdiv_rst =1 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + + divisor = (gd->bus_clk +MAX_A_CLK -1 ) /MAX_A_CLK ; +if (divisor <=4 ) { + a_clkdiv = divisor -1 ; + }else if (divisor <=6 ) { + a_clkdiv =4 ; + divisor =6 ; + }else if (divisor <=8 ) { + a_clkdiv =5 ; + divisor =8 ; + }else if (divisor <=16 ) { + a_clkdiv =6 ; + divisor =16 ; + }else if (divisor <=24 ) { + a_clkdiv =7 ; + divisor =24 ; + }else { +printf ("Unable to determine SATA clock divisor\n" ); +return -1 ; + } + +/* Calculate the final clock rate */ + a_clk = gd->bus_clk / divisor; + + uctl_ctl.s.a_clkdiv_sel = a_clkdiv; + uctl_ctl.s.a_clk_en =1 ; + uctl_ctl.s.a_clk_byp_sel =0 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.a_clkdiv_rst =0 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +udelay (1 ); + +return 0 ; +} + +static int __sata_dlm_init_cn70xx (int qlm,int baud_mhz,int ref_clk_sel,int ref_clk_input) +{ +cvmx_gserx_sata_cfg_t sata_cfg; +cvmx_gserx_sata_lane_rst_t sata_lane_rst; +cvmx_gserx_dlmx_phy_reset_t dlmx_phy_reset; +cvmx_gserx_dlmx_test_powerdown_t dlmx_test_powerdown; +cvmx_gserx_sata_ref_ssp_en_t ref_ssp_en; +cvmx_gserx_dlmx_mpll_multiplier_t mpll_multiplier; +cvmx_gserx_dlmx_ref_clkdiv2_t ref_clkdiv2; +cvmx_sata_uctl_shim_cfg_t shim_cfg; +cvmx_gserx_phyx_ovrd_in_lo_t ovrd_in; +cvmx_sata_uctl_ctl_t uctl_ctl; +int sata_ref_clk; + +debug ("%s(%d, %d, %d, %d)\n" , __func__, qlm, baud_mhz, ref_clk_sel, ref_clk_input); + +switch (ref_clk_sel) { +case 0 : + sata_ref_clk =100 ; +break ; +case 1 : + sata_ref_clk =125 ; +break ; +case 2 : + sata_ref_clk =156 ; +break ; +default : +printf ("%s: Invalid reference clock select %d for qlm %d\n" , __func__, + ref_clk_sel, qlm); +return -1 ; + } + +/* 5. Set GSERX0_SATA_CFG[SATA_EN] = 1 to configure DLM2 multiplexing. +*/ + sata_cfg.u64 =csr_rd (CVMX_GSERX_SATA_CFG (0 )); + sata_cfg.s.sata_en =1 ; +csr_wr (CVMX_GSERX_SATA_CFG (0 ), sata_cfg.u64); + +/* 1. Write GSER(0)_DLM2_REFCLK_SEL[REFCLK_SEL] if required for +* reference-clock selection. +*/ +if (ref_clk_input <2 ) { +csr_wr (CVMX_GSERX_DLMX_REFCLK_SEL (qlm,0 ), ref_clk_input); +csr_wr (CVMX_GSERX_DLMX_REF_USE_PAD (qlm,0 ),0 ); + }else { +csr_wr (CVMX_GSERX_DLMX_REF_USE_PAD (qlm,0 ),1 ); + } + + ref_ssp_en.u64 =csr_rd (CVMX_GSERX_SATA_REF_SSP_EN (0 )); + ref_ssp_en.s.ref_ssp_en =1 ; +csr_wr (CVMX_GSERX_SATA_REF_SSP_EN (0 ), ref_ssp_en.u64); + +/* Apply workaround for Errata (G-20669) MPLL may not come up. */ + +/* Set REF_CLKDIV2 based on the Ref Clock */ + ref_clkdiv2.u64 =csr_rd (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 )); +if (sata_ref_clk ==100 ) + ref_clkdiv2.s.ref_clkdiv2 =0 ; +else + ref_clkdiv2.s.ref_clkdiv2 =1 ; +csr_wr (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 ), ref_clkdiv2.u64); + +/* 1. Ensure GSER(0)_DLM(0..2)_PHY_RESET[PHY_RESET] is set. */ + dlmx_phy_reset.u64 =csr_rd (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 )); + dlmx_phy_reset.s.phy_reset =1 ; +csr_wr (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 ), dlmx_phy_reset.u64); + +/* 2. If SGMII or QSGMII or RXAUI (i.e. if DLM0) set +* GSER(0)_DLM(0)_MPLL_EN[MPLL_EN] to one. +*/ + +/* 3. Set GSER(0)_DLM(0..2)_MPLL_MULTIPLIER[MPLL_MULTIPLIER] +* to the value in the preceding table, which is different +* than the desired setting prescribed by the HRM. +*/ + + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); +if (sata_ref_clk ==100 ) + mpll_multiplier.s.mpll_multiplier =35 ; +else + mpll_multiplier.s.mpll_multiplier =56 ; +csr_wr (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 ), mpll_multiplier.u64); + +/* 3. Clear GSER0_DLM2_TEST_POWERDOWN[TEST_POWERDOWN] = 0 */ + dlmx_test_powerdown.u64 =csr_rd (CVMX_GSERX_DLMX_TEST_POWERDOWN (qlm,0 )); + dlmx_test_powerdown.s.test_powerdown =0 ; +csr_wr (CVMX_GSERX_DLMX_TEST_POWERDOWN (qlm,0 ), dlmx_test_powerdown.u64); + +/* 4. Clear either/both lane0 and lane1 resets: +* GSER0_SATA_LANE_RST[L0_RST, L1_RST] = 0. +*/ + sata_lane_rst.u64 =csr_rd (CVMX_GSERX_SATA_LANE_RST (0 )); + sata_lane_rst.s.l0_rst =0 ; + sata_lane_rst.s.l1_rst =0 ; +csr_wr (CVMX_GSERX_SATA_LANE_RST (0 ), sata_lane_rst.u64); + +udelay (1 ); + +/* 5. Clear GSER0_DLM2_PHY_RESET */ + dlmx_phy_reset.u64 =csr_rd (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 )); + dlmx_phy_reset.s.phy_reset =0 ; +csr_wr (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 ), dlmx_phy_reset.u64); + +/* 6. If PCIe or SATA (i.e. if DLM1 or DLM2), set both MPLL_EN +* and MPLL_EN_OVRD to one in GSER(0)_PHY(1..2)_OVRD_IN_LO. +*/ + ovrd_in.u64 =csr_rd (CVMX_GSERX_PHYX_OVRD_IN_LO (qlm,0 )); + ovrd_in.s.mpll_en =1 ; + ovrd_in.s.mpll_en_ovrd =1 ; +csr_wr (CVMX_GSERX_PHYX_OVRD_IN_LO (qlm,0 ), ovrd_in.u64); + +/* 7. Decrease MPLL_MULTIPLIER by one continually until it reaches +* the desired long-term setting, ensuring that each MPLL_MULTIPLIER +* value is constant for at least 1 msec before changing to the next +* value. The desired long-term setting is as indicated in HRM tables +* 21-1, 21-2, and 21-3. This is not required with the HRM +* sequence. +*/ + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); +if (sata_ref_clk ==100 ) + mpll_multiplier.s.mpll_multiplier =0x1e ; +else + mpll_multiplier.s.mpll_multiplier =0x30 ; +csr_wr (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 ), mpll_multiplier.u64); + +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_MPLL_STATUS (qlm,0 ), + cvmx_gserx_dlmx_mpll_status_t, mpll_status, ==, 1, 10000)) { +printf ("ERROR: SATA MPLL failed to set\n" ); +return -1 ; + } + +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_RX_STATUS (qlm,0 ), cvmx_gserx_dlmx_rx_status_t, + rx0_status, ==, 1, 10000)) { +printf ("ERROR: SATA RX0_STATUS failed to set\n" ); +return -1 ; + } +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_DLMX_RX_STATUS (qlm,0 ), cvmx_gserx_dlmx_rx_status_t, + rx1_status, ==, 1, 10000)) { +printf ("ERROR: SATA RX1_STATUS failed to set\n" ); +return -1 ; + } + +/* 8. Deassert UCTL and UAHC resets: +* a. SATA_UCTL_CTL[UCTL_RST] = 0 +* b. SATA_UCTL_CTL[UAHC_RST] = 0 +* c. Wait 10 ACLK cycles before accessing any ACLK-only registers. +*/ + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.sata_uctl_rst =0 ; + uctl_ctl.s.sata_uahc_rst =0 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +udelay (1 ); + +/* 9. Enable conditional SCLK of UCTL by writing +* SATA_UCTL_CTL[CSCLK_EN] = 1 +*/ + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.csclk_en =1 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +/* 10. Initialize UAHC as described in the AHCI Specification (UAHC_* +* registers +*/ + +/* set-up endian mode */ + shim_cfg.u64 =csr_rd (CVMX_SATA_UCTL_SHIM_CFG ); + shim_cfg.s.dma_endian_mode =1 ; + shim_cfg.s.csr_endian_mode =3 ; +csr_wr (CVMX_SATA_UCTL_SHIM_CFG , shim_cfg.u64); + +return 0 ; +} + +/** +* Initializes DLM 4 for SATA +* +* @param qlm Must be 4. +* @param baud_mhz Baud rate for SATA +* @param ref_clk_sel Selects the speed of the reference clock where: +* 0 = 100MHz, 1 = 125MHz and 2 = 156.25MHz +* @param ref_clk_input Reference clock input where 0 = external QLM clock, +* 1 = qlmc_ref_clk0 and 2 = qlmc_ref_clk1 +*/ +static int __sata_dlm_init_cn73xx (int qlm,int baud_mhz,int ref_clk_sel,int ref_clk_input) +{ +cvmx_sata_uctl_shim_cfg_t shim_cfg; +cvmx_gserx_refclk_sel_t refclk_sel; +cvmx_gserx_phy_ctl_t phy_ctl; +cvmx_gserx_rx_pwr_ctrl_p2_t pwr_ctrl_p2; +cvmx_gserx_lanex_misc_cfg_0_t misc_cfg_0; +cvmx_gserx_sata_lane_rst_t lane_rst; +cvmx_gserx_pll_px_mode_0_t pmode_0; +cvmx_gserx_pll_px_mode_1_t pmode_1; +cvmx_gserx_lane_px_mode_0_t lane_pmode_0; +cvmx_gserx_lane_px_mode_1_t lane_pmode_1; +cvmx_gserx_cfg_t gserx_cfg; +cvmx_sata_uctl_ctl_t uctl_ctl; +int l; +int i; + +/* +* 1. Configure the SATA +*/ + +/* +* 2. Configure the QLM Reference clock +* Set GSERX_REFCLK_SEL.COM_CLK_SEL to source reference clock +* from the external clock mux. +* GSERX_REFCLK_SEL.USE_COM1 to select qlmc_refclkn/p_1 or +* leave clear to select qlmc_refclkn/p_0 +*/ + refclk_sel.u64 =0 ; +if (ref_clk_input ==0 ) {/* External ref clock */ + refclk_sel.s.com_clk_sel =0 ; + refclk_sel.s.use_com1 =0 ; + }else if (ref_clk_input ==1 ) {/* Common reference clock 0 */ + refclk_sel.s.com_clk_sel =1 ; + refclk_sel.s.use_com1 =0 ; + }else {/* Common reference clock 1 */ + refclk_sel.s.com_clk_sel =1 ; + refclk_sel.s.use_com1 =1 ; + } + +if (ref_clk_sel !=0 ) { +printf ("Wrong reference clock selected for QLM4\n" ); +return -1 ; + } + +csr_wr (CVMX_GSERX_REFCLK_SEL (qlm), refclk_sel.u64); + +/* Reset the QLM after changing the reference clock */ + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (qlm)); + phy_ctl.s.phy_reset =1 ; +csr_wr (CVMX_GSERX_PHY_CTL (qlm), phy_ctl.u64); + +udelay (1 ); + +/* +* 3. Configure the QLM for SATA mode set GSERX_CFG.SATA +*/ + gserx_cfg.u64 =0 ; + gserx_cfg.s.sata =1 ; +csr_wr (CVMX_GSERX_CFG (qlm), gserx_cfg.u64); + +/* +* 12. Clear the appropriate lane resets +* clear GSERX_SATA_LANE_RST.LX_RST where X is the lane number 0-1. +*/ + lane_rst.u64 =csr_rd (CVMX_GSERX_SATA_LANE_RST (qlm)); + lane_rst.s.l0_rst =0 ; + lane_rst.s.l1_rst =0 ; +csr_wr (CVMX_GSERX_SATA_LANE_RST (qlm), lane_rst.u64); +csr_rd (CVMX_GSERX_SATA_LANE_RST (qlm)); + +udelay (1 ); + +/* +* 4. Take the PHY out of reset +* Write GSERX_PHY_CTL.PHY_RESET to a zero +*/ + phy_ctl.u64 =csr_rd (CVMX_GSERX_PHY_CTL (qlm)); + phy_ctl.s.phy_reset =0 ; +csr_wr (CVMX_GSERX_PHY_CTL (qlm), phy_ctl.u64); + +/* Wait for reset to complete and the PLL to lock */ +/* PCIe mode doesn't become ready until the PEM block attempts to bring +* the interface up. Skip this check for PCIe +*/ +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_QLM_STAT (qlm), cvmx_gserx_qlm_stat_t, + rst_rdy, ==, 1, 10000)) { +printf ("QLM%d: Timeout waiting for GSERX_QLM_STAT[rst_rdy]\n" , qlm); +return -1 ; + } + +/* Workaround for errata GSER-30310: SATA HDD Not Ready due to +* PHY SDLL/LDLL lockup@3GHz +*/ +for (i =0 ; i <2 ; i++) { +cvmx_gserx_slicex_pcie1_mode_t pcie1; +cvmx_gserx_slicex_pcie2_mode_t pcie2; +cvmx_gserx_slicex_pcie3_mode_t pcie3; + + pcie1.u64 =csr_rd (CVMX_GSERX_SLICEX_PCIE1_MODE (i, qlm)); + pcie1.s.rx_pi_bwsel =1 ; + pcie1.s.rx_ldll_bwsel =1 ; + pcie1.s.rx_sdll_bwsel =1 ; +csr_wr (CVMX_GSERX_SLICEX_PCIE1_MODE (i, qlm), pcie1.u64); + + pcie2.u64 =csr_rd (CVMX_GSERX_SLICEX_PCIE2_MODE (i, qlm)); + pcie2.s.rx_pi_bwsel =1 ; + pcie2.s.rx_ldll_bwsel =1 ; + pcie2.s.rx_sdll_bwsel =1 ; +csr_wr (CVMX_GSERX_SLICEX_PCIE2_MODE (i, qlm), pcie2.u64); + + pcie3.u64 =csr_rd (CVMX_GSERX_SLICEX_PCIE3_MODE (i, qlm)); + pcie3.s.rx_pi_bwsel =1 ; + pcie3.s.rx_ldll_bwsel =1 ; + pcie3.s.rx_sdll_bwsel =1 ; +csr_wr (CVMX_GSERX_SLICEX_PCIE3_MODE (i, qlm), pcie3.u64); + } + +/* +* 7. Change P2 termination +* Clear GSERX_RX_PWR_CTRL_P2.P2_RX_SUBBLK_PD[0] (Termination) +*/ + pwr_ctrl_p2.u64 =csr_rd (CVMX_GSERX_RX_PWR_CTRL_P2 (qlm)); + pwr_ctrl_p2.s.p2_rx_subblk_pd &=0x1e ; +csr_wr (CVMX_GSERX_RX_PWR_CTRL_P2 (qlm), pwr_ctrl_p2.u64); + +/* +* 8. Modify the Electrical IDLE Detect on delay +* Change GSERX_LANE(0..3)_MISC_CFG_0.EIE_DET_STL_ON_TIME to a 0x4 +*/ +for (i =0 ; i <2 ; i++) { + misc_cfg_0.u64 =csr_rd (CVMX_GSERX_LANEX_MISC_CFG_0 (i, qlm)); + misc_cfg_0.s.eie_det_stl_on_time =4 ; +csr_wr (CVMX_GSERX_LANEX_MISC_CFG_0 (i, qlm), misc_cfg_0.u64); + } + +/* +* 9. Modify the PLL and Lane Protocol Mode registers to configure +* the PHY for SATA. +* (Configure all 3 PLLs, doesn't matter what speed it is configured) +*/ + +/* Errata (GSER-26724) SATA never indicates GSER QLM_STAT[RST_RDY] +* We program PLL_PX_MODE_0 last due to this errata +*/ +for (l =0 ; l <3 ; l++) { + pmode_1.u64 =csr_rd (CVMX_GSERX_PLL_PX_MODE_1 (l, qlm)); + lane_pmode_0.u64 =csr_rd (CVMX_GSERX_LANE_PX_MODE_0 (l, qlm)); + lane_pmode_1.u64 =csr_rd (CVMX_GSERX_LANE_PX_MODE_1 (l, qlm)); + + pmode_1.s.pll_cpadj =0x2 ; + pmode_1.s.pll_opr =0x0 ; + pmode_1.s.pll_div =0x1e ; + pmode_1.s.pll_pcie3en =0x0 ; + pmode_1.s.pll_16p5en =0x0 ; + + lane_pmode_0.s.ctle =0x0 ; + lane_pmode_0.s.pcie =0x0 ; + lane_pmode_0.s.tx_ldiv =0x0 ; + lane_pmode_0.s.srate =0 ; + lane_pmode_0.s.tx_mode =0x3 ; + lane_pmode_0.s.rx_mode =0x3 ; + + lane_pmode_1.s.vma_mm =1 ; + lane_pmode_1.s.vma_fine_cfg_sel =0 ; + lane_pmode_1.s.cdr_fgain =0xa ; + lane_pmode_1.s.ph_acc_adj =0x15 ; + +if (l ==R_2_5G_REFCLK100 ) + lane_pmode_0.s.rx_ldiv =0x2 ; +else if (l ==R_5G_REFCLK100 ) + lane_pmode_0.s.rx_ldiv =0x1 ; +else + lane_pmode_0.s.rx_ldiv =0x0 ; + +csr_wr (CVMX_GSERX_PLL_PX_MODE_1 (l, qlm), pmode_1.u64); +csr_wr (CVMX_GSERX_LANE_PX_MODE_0 (l, qlm), lane_pmode_0.u64); +csr_wr (CVMX_GSERX_LANE_PX_MODE_1 (l, qlm), lane_pmode_1.u64); + } + +for (l =0 ; l <3 ; l++) { + pmode_0.u64 =csr_rd (CVMX_GSERX_PLL_PX_MODE_0 (l, qlm)); + pmode_0.s.pll_icp =0x1 ; + pmode_0.s.pll_rloop =0x3 ; + pmode_0.s.pll_pcs_div =0x5 ; +csr_wr (CVMX_GSERX_PLL_PX_MODE_0 (l, qlm), pmode_0.u64); + } + +for (i =0 ; i <2 ; i++) { +cvmx_gserx_slicex_rx_sdll_ctrl_t rx_sdll; + + rx_sdll.u64 =csr_rd (CVMX_GSERX_SLICEX_RX_SDLL_CTRL (i, qlm)); + rx_sdll.s.pcs_sds_oob_clk_ctrl =2 ; + rx_sdll.s.pcs_sds_rx_sdll_tune =0 ; + rx_sdll.s.pcs_sds_rx_sdll_swsel =0 ; +csr_wr (CVMX_GSERX_SLICEX_RX_SDLL_CTRL (i, qlm), rx_sdll.u64); + } + +for (i =0 ; i <2 ; i++) { +cvmx_gserx_lanex_misc_cfg_0_t misc_cfg; + + misc_cfg.u64 =csr_rd (CVMX_GSERX_LANEX_MISC_CFG_0 (i, qlm)); + misc_cfg.s.use_pma_polarity =0 ; + misc_cfg.s.cfg_pcs_loopback =0 ; + misc_cfg.s.pcs_tx_mode_ovrrd_en =0 ; + misc_cfg.s.pcs_rx_mode_ovrrd_en =0 ; + misc_cfg.s.cfg_eie_det_cnt =0 ; + misc_cfg.s.eie_det_stl_on_time =4 ; + misc_cfg.s.eie_det_stl_off_time =0 ; + misc_cfg.s.tx_bit_order =1 ; + misc_cfg.s.rx_bit_order =1 ; +csr_wr (CVMX_GSERX_LANEX_MISC_CFG_0 (i, qlm), misc_cfg.u64); + } + +/* Wait for reset to complete and the PLL to lock */ +/* PCIe mode doesn't become ready until the PEM block attempts to bring +* the interface up. Skip this check for PCIe +*/ +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_QLM_STAT (qlm), cvmx_gserx_qlm_stat_t, + rst_rdy, ==, 1, 10000)) { +printf ("QLM%d: Timeout waiting for GSERX_QLM_STAT[rst_rdy]\n" , qlm); +return -1 ; + } + +/* Poll GSERX_SATA_STATUS for P0_RDY = 1 */ +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_SATA_STATUS (qlm), cvmx_gserx_sata_status_t, + p0_rdy, ==, 1, 10000)) { +printf ("QLM4: Timeout waiting for GSERX_SATA_STATUS[p0_rdy]\n" ); +return -1 ; + } + +/* Poll GSERX_SATA_STATUS for P1_RDY = 1 */ +if (CVMX_WAIT_FOR_FIELD64 (CVMX_GSERX_SATA_STATUS (qlm), cvmx_gserx_sata_status_t, + p1_rdy, ==, 1, 10000)) { +printf ("QLM4: Timeout waiting for GSERX_SATA_STATUS[p1_rdy]\n" ); +return -1 ; + } + +udelay (2000 ); + +/* 6. Deassert UCTL and UAHC resets: +* a. SATA_UCTL_CTL[UCTL_RST] = 0 +* b. SATA_UCTL_CTL[UAHC_RST] = 0 +* c. Wait 10 ACLK cycles before accessing any ACLK-only registers. +*/ + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.sata_uctl_rst =0 ; + uctl_ctl.s.sata_uahc_rst =0 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +udelay (1 ); + +/* 7. Enable conditional SCLK of UCTL by writing +* SATA_UCTL_CTL[CSCLK_EN] = 1 +*/ + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.csclk_en =1 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +/* set-up endian mode */ + shim_cfg.u64 =csr_rd (CVMX_SATA_UCTL_SHIM_CFG ); + shim_cfg.s.dma_endian_mode =1 ; + shim_cfg.s.csr_endian_mode =3 ; +csr_wr (CVMX_SATA_UCTL_SHIM_CFG , shim_cfg.u64); + +return 0 ; +} + +static int __dlm2_sata_uahc_init_cn70xx (int baud_mhz) +{ +cvmx_sata_uahc_gbl_cap_t gbl_cap; +cvmx_sata_uahc_px_sctl_t sctl; +cvmx_sata_uahc_gbl_pi_t pi; +cvmx_sata_uahc_px_cmd_t cmd; +cvmx_sata_uahc_px_sctl_t sctl0, sctl1; +cvmx_sata_uahc_px_ssts_t ssts; +cvmx_sata_uahc_px_tfd_t tfd; +cvmx_sata_uahc_gbl_timer1ms_t gbl_timer1ms; +u64 done; +int result =-1 ; +int retry_count =0 ; +int spd; + +/* From the synopsis data book, SATA_UAHC_GBL_TIMER1MS is the +* AMBA clock in MHz * 1000, which is a_clk(Hz) / 1000 +*/ + gbl_timer1ms.u32 =csr_rd32 (CVMX_SATA_UAHC_GBL_TIMER1MS ); + gbl_timer1ms.s.timv = a_clk /1000 ; +csr_wr32 (CVMX_SATA_UAHC_GBL_TIMER1MS , gbl_timer1ms.u32); + gbl_timer1ms.u32 =csr_rd32 (CVMX_SATA_UAHC_GBL_TIMER1MS ); + +/* Set-u global capabilities reg (GBL_CAP) */ + gbl_cap.u32 =csr_rd32 (CVMX_SATA_UAHC_GBL_CAP ); +debug ("%s: SATA_UAHC_GBL_CAP before: 0x%x\n" , __func__, gbl_cap.u32); + gbl_cap.s.sss =1 ; + gbl_cap.s.smps =1 ; +csr_wr32 (CVMX_SATA_UAHC_GBL_CAP , gbl_cap.u32); + gbl_cap.u32 =csr_rd32 (CVMX_SATA_UAHC_GBL_CAP ); +debug ("%s: SATA_UAHC_GBL_CAP after: 0x%x\n" , __func__, gbl_cap.u32); + +/* Set-up global hba control reg (interrupt enables) */ +/* Set-up port SATA control registers (speed limitation) */ +if (baud_mhz ==1500 ) + spd =1 ; +else if (baud_mhz ==3000 ) + spd =2 ; +else + spd =3 ; + + sctl.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (0 )); +debug ("%s: SATA_UAHC_P0_SCTL before: 0x%x\n" , __func__, sctl.u32); + sctl.s.spd = spd; +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (0 ), sctl.u32); + sctl.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (0 )); +debug ("%s: SATA_UAHC_P0_SCTL after: 0x%x\n" , __func__, sctl.u32); + sctl.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (1 )); +debug ("%s: SATA_UAHC_P1_SCTL before: 0x%x\n" , __func__, sctl.u32); + sctl.s.spd = spd; +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (1 ), sctl.u32); + sctl.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (1 )); +debug ("%s: SATA_UAHC_P1_SCTL after: 0x%x\n" , __func__, sctl.u32); + +/* Set-up ports implemented reg. */ + pi.u32 =csr_rd32 (CVMX_SATA_UAHC_GBL_PI ); +debug ("%s: SATA_UAHC_GBL_PI before: 0x%x\n" , __func__, pi.u32); + pi.s.pi =3 ; +csr_wr32 (CVMX_SATA_UAHC_GBL_PI , pi.u32); + pi.u32 =csr_rd32 (CVMX_SATA_UAHC_GBL_PI ); +debug ("%s: SATA_UAHC_GBL_PI after: 0x%x\n" , __func__, pi.u32); + +retry0: +/* Clear port SERR and IS registers */ +csr_wr32 (CVMX_SATA_UAHC_PX_SERR (0 ),csr_rd32 (CVMX_SATA_UAHC_PX_SERR (0 ))); +csr_wr32 (CVMX_SATA_UAHC_PX_IS (0 ),csr_rd32 (CVMX_SATA_UAHC_PX_IS (0 ))); + +/* Set spin-up, power on, FIS RX enable, start, active */ + cmd.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_CMD (0 )); +debug ("%s: SATA_UAHC_P0_CMD before: 0x%x\n" , __func__, cmd.u32); + cmd.s.fre =1 ; + cmd.s.sud =1 ; + cmd.s.pod =1 ; + cmd.s.st =1 ; + cmd.s.icc =1 ; + cmd.s.fbscp =1 ;/* Enable FIS-based switching */ +csr_wr32 (CVMX_SATA_UAHC_PX_CMD (0 ), cmd.u32); + cmd.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_CMD (0 )); +debug ("%s: SATA_UAHC_P0_CMD after: 0x%x\n" , __func__, cmd.u32); + + sctl0.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (0 )); + sctl0.s.det =1 ; +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (0 ), sctl0.u32); + +/* check status */ + done =get_timer (0 ); +while (1 ) { + ssts.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SSTS (0 )); + +if (ssts.s.ipm ==1 && ssts.s.det ==3 ) { + result =0 ; +break ; + }else if (get_timer (done) >100 ) { + result =-1 ; +break ; + } + +udelay (100 ); + } + +if (result !=-1 ) { +/* Clear the PxSERR Register, by writing '1s' to each +* implemented bit location +*/ +csr_wr32 (CVMX_SATA_UAHC_PX_SERR (0 ),-1 ); + +/* +* Wait for indication that SATA drive is ready. This is +* determined via an examination of PxTFD.STS. If PxTFD.STS.BSY +* PxTFD.STS.DRQ, and PxTFD.STS.ERR are all '0', prior to the +* maximum allowed time as specified in the ATA/ATAPI-7 +* specification, the device is ready. +*/ +/* +* Wait for the device to be ready. BSY(7), DRQ(3), and ERR(0) +* must be clear +*/ + done =get_timer (0 ); +while (1 ) { + tfd.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_TFD (0 )); +if ((tfd.s.sts &0x89 ) ==0 ) { + result =0 ; +break ; + }else if (get_timer (done) >500 ) { +if (retry_count <3 ) { + sctl0.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (0 )); + sctl0.s.det =1 ;/* Perform interface reset */ +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (0 ), sctl0.u32); +udelay (1000 );/* 1ms dicated by AHCI 1.3 spec */ + sctl0.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (0 )); + sctl0.s.det =0 ;/* Perform interface reset */ +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (0 ), sctl0.u32); + retry_count++; + goto retry0; + } + result =-1 ; +break ; + } + +udelay (100 ); + } + } + +if (result ==-1 ) +printf ("SATA0: not available\n" ); +else +printf ("SATA0: available\n" ); + + sctl1.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (1 )); + sctl1.s.det =1 ; +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (1 ), sctl1.u32); + + result =-1 ; + retry_count =0 ; + +retry1: +/* Clear port SERR and IS registers */ +csr_wr32 (CVMX_SATA_UAHC_PX_SERR (1 ),csr_rd32 (CVMX_SATA_UAHC_PX_SERR (1 ))); +csr_wr32 (CVMX_SATA_UAHC_PX_IS (1 ),csr_rd32 (CVMX_SATA_UAHC_PX_IS (1 ))); + +/* Set spin-up, power on, FIS RX enable, start, active */ + cmd.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_CMD (1 )); +debug ("%s: SATA_UAHC_P1_CMD before: 0x%x\n" , __func__, cmd.u32); + cmd.s.fre =1 ; + cmd.s.sud =1 ; + cmd.s.pod =1 ; + cmd.s.st =1 ; + cmd.s.icc =1 ; + cmd.s.fbscp =1 ;/* Enable FIS-based switching */ +csr_wr32 (CVMX_SATA_UAHC_PX_CMD (1 ), cmd.u32); + cmd.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_CMD (1 )); +debug ("%s: SATA_UAHC_P1_CMD after: 0x%x\n" , __func__, cmd.u32); + +/* check status */ + done =get_timer (0 ); +while (1 ) { + ssts.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SSTS (1 )); + +if (ssts.s.ipm ==1 && ssts.s.det ==3 ) { + result =0 ; +break ; + }else if (get_timer (done) >1000 ) { + result =-1 ; +break ; + } + +udelay (100 ); + } + +if (result !=-1 ) { +/* Clear the PxSERR Register, by writing '1s' to each +* implemented bit location +*/ +csr_wr32 (CVMX_SATA_UAHC_PX_SERR (1 ),csr_rd32 (CVMX_SATA_UAHC_PX_SERR (1 ))); + +/* +* Wait for indication that SATA drive is ready. This is +* determined via an examination of PxTFD.STS. If PxTFD.STS.BSY +* PxTFD.STS.DRQ, and PxTFD.STS.ERR are all '0', prior to the +* maximum allowed time as specified in the ATA/ATAPI-7 +* specification, the device is ready. +*/ +/* +* Wait for the device to be ready. BSY(7), DRQ(3), and ERR(0) +* must be clear +*/ + done =get_timer (0 ); +while (1 ) { + tfd.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_TFD (1 )); +if ((tfd.s.sts &0x89 ) ==0 ) { + result =0 ; +break ; + }else if (get_timer (done) >500 ) { +if (retry_count <3 ) { + sctl0.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (1 )); + sctl0.s.det =1 ;/* Perform interface reset */ +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (1 ), sctl0.u32); +udelay (1000 );/* 1ms dicated by AHCI 1.3 spec */ + sctl0.u32 =csr_rd32 (CVMX_SATA_UAHC_PX_SCTL (1 )); + sctl0.s.det =0 ;/* Perform interface reset */ +csr_wr32 (CVMX_SATA_UAHC_PX_SCTL (1 ), sctl0.u32); + retry_count++; + goto retry1; + } + result =-1 ; +break ; + } + +udelay (100 ); + } + } + +if (result ==-1 ) +printf ("SATA1: not available\n" ); +else +printf ("SATA1: available\n" ); + +return 0 ; +} + +static int __sata_bist_cn70xx (int qlm,int baud_mhz,int ref_clk_sel,int ref_clk_input) +{ +cvmx_sata_uctl_bist_status_t bist_status; +cvmx_sata_uctl_ctl_t uctl_ctl; +cvmx_sata_uctl_shim_cfg_t shim_cfg; +u64 done; +int result =-1 ; + +debug ("%s(%d, %d, %d, %d)\n" , __func__, qlm, baud_mhz, ref_clk_sel, ref_clk_input); + bist_status.u64 =csr_rd (CVMX_SATA_UCTL_BIST_STATUS ); + + { +if (__dlm2_sata_uctl_init_cn70xx ()) { +printf ("ERROR: Failed to initialize SATA UCTL CSRs\n" ); +return -1 ; + } +if (OCTEON_IS_MODEL (OCTEON_CN73XX )) + result =__sata_dlm_init_cn73xx (qlm, baud_mhz, ref_clk_sel, ref_clk_input); +else + result =__sata_dlm_init_cn70xx (qlm, baud_mhz, ref_clk_sel, ref_clk_input); +if (result) { +printf ("ERROR: Failed to initialize SATA GSER CSRs\n" ); +return -1 ; + } + + uctl_ctl.u64 =csr_rd (CVMX_SATA_UCTL_CTL ); + uctl_ctl.s.start_bist =1 ; +csr_wr (CVMX_SATA_UCTL_CTL , uctl_ctl.u64); + +/* Set-up for a 1 sec timer. */ + done =get_timer (0 ); +while (1 ) { + bist_status.u64 =csr_rd (CVMX_SATA_UCTL_BIST_STATUS ); +if ((bist_status.s.uctl_xm_r_bist_ndone | + bist_status.s.uctl_xm_w_bist_ndone | + bist_status.s.uahc_p0_rxram_bist_ndone | + bist_status.s.uahc_p1_rxram_bist_ndone | + bist_status.s.uahc_p0_txram_bist_ndone | + bist_status.s.uahc_p1_txram_bist_ndone) ==0 ) { + result =0 ; +break ; + }else if (get_timer (done) >1000 ) { + result =-1 ; +break ; + } + +udelay (100 ); + } +if (result ==-1 ) { +printf ("ERROR: SATA_UCTL_BIST_STATUS = 0x%llx\n" , + (unsigned long long )bist_status.u64); +return -1 ; + } + +debug ("%s: Initializing UAHC\n" , __func__); +if (__dlm2_sata_uahc_init_cn70xx (baud_mhz)) { +printf ("ERROR: Failed to initialize SATA UAHC CSRs\n" ); +return -1 ; + } + } + +/* Change CSR_ENDIAN_MODE to big endian to use Open Source AHCI SATA +* driver +*/ + shim_cfg.u64 =csr_rd (CVMX_SATA_UCTL_SHIM_CFG ); + shim_cfg.s.csr_endian_mode =1 ; +csr_wr (CVMX_SATA_UCTL_SHIM_CFG , shim_cfg.u64); + +return 0 ; +} + +static int __setup_sata (int qlm,int baud_mhz,int ref_clk_sel,int ref_clk_input) +{ +debug ("%s(%d, %d, %d, %d)\n" , __func__, qlm, baud_mhz, ref_clk_sel, ref_clk_input); +return __sata_bist_cn70xx (qlm, baud_mhz, ref_clk_sel, ref_clk_input); +} + +static int __dlmx_setup_pcie_cn70xx (int qlm,enum cvmx_qlm_mode mode,int gen2,int rc, +int ref_clk_sel,int ref_clk_input) +{ +cvmx_gserx_dlmx_phy_reset_t dlmx_phy_reset; +cvmx_gserx_dlmx_test_powerdown_t dlmx_test_powerdown; +cvmx_gserx_dlmx_mpll_multiplier_t mpll_multiplier; +cvmx_gserx_dlmx_ref_clkdiv2_t ref_clkdiv2; +static const u8 ref_clk_mult[2 ] = {35 ,56 };/* 100 & 125 MHz ref clock supported. */ + +debug ("%s(%d, %d, %d, %d, %d, %d)\n" , __func__, qlm, mode, gen2, rc, ref_clk_sel, + ref_clk_input); +if (rc ==0 ) { +debug ("Skipping initializing PCIe dlm %d in endpoint mode\n" , qlm); +return 0 ; + } + +if (qlm >0 && ref_clk_input >1 ) { +printf ("%s: Error: ref_clk_input can only be 0 or 1 for QLM %d\n" , + __func__, qlm); +return -1 ; + } + +if (ref_clk_sel >OCTEON_QLM_REF_CLK_125MHZ ) { +printf ("%s: Error: ref_clk_sel can only be 100 or 125 MHZ.\n" , __func__); +return -1 ; + } + +/* 1. Write GSER0_DLM(1..2)_REFCLK_SEL[REFCLK_SEL] if required for +* reference-clock selection +*/ + +csr_wr (CVMX_GSERX_DLMX_REFCLK_SEL (qlm,0 ), ref_clk_input); + +/* 2. If required, write GSER0_DLM(1..2)_REF_CLKDIV2[REF_CLKDIV2] = 1 +* (must be set if reference clock >= 100 MHz) +*/ + +/* 4. Configure the PCIE PIPE: +* a. Write GSER0_PCIE_PIPE_PORT_SEL[PIPE_PORT_SEL] to configure the +* PCIE PIPE. +* 0x0 = disables all pipes +* 0x1 = enables pipe0 only (PEM0 4-lane) +* 0x2 = enables pipes 0 and 1 (PEM0 and PEM1 2-lanes each) +* 0x3 = enables pipes 0, 1, 2, and 3 (PEM0, PEM1, and PEM3 are +* one-lane each) +* b. Configure GSER0_PCIE_PIPE_PORT_SEL[CFG_PEM1_DLM2]. If PEM1 is +* to be configured, this bit must reflect which DLM it is logically +* tied to. This bit sets multiplexing logic in GSER, and it is used +* by the RST logic to determine when the MAC can come out of reset. +* 0 = PEM1 is tied to DLM1 (for 3 x 1 PCIe mode). +* 1 = PEM1 is tied to DLM2 (for all other PCIe modes). +*/ +if (qlm ==1 ) { +cvmx_gserx_pcie_pipe_port_sel_t pipe_port; + + pipe_port.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_PORT_SEL (0 )); + pipe_port.s.cfg_pem1_dlm2 = (mode ==CVMX_QLM_MODE_PCIE_1X1 ) ?1 :0 ; + pipe_port.s.pipe_port_sel = + (mode ==CVMX_QLM_MODE_PCIE ) ?1 :/* PEM0 only */ + (mode ==CVMX_QLM_MODE_PCIE_1X2 ) ?2 :/* PEM0-1 */ + (mode ==CVMX_QLM_MODE_PCIE_1X1 ) ?3 :/* PEM0-2 */ + (mode ==CVMX_QLM_MODE_PCIE_2X1 ) ?3 :/* PEM0-1 */ +0 ;/* PCIe disabled */ +csr_wr (CVMX_GSERX_PCIE_PIPE_PORT_SEL (0 ), pipe_port.u64); + } + +/* Apply workaround for Errata (G-20669) MPLL may not come up. */ + +/* Set REF_CLKDIV2 based on the Ref Clock */ + ref_clkdiv2.u64 =csr_rd (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 )); + ref_clkdiv2.s.ref_clkdiv2 = ref_clk_sel >0 ; +csr_wr (CVMX_GSERX_DLMX_REF_CLKDIV2 (qlm,0 ), ref_clkdiv2.u64); + +/* 1. Ensure GSER(0)_DLM(0..2)_PHY_RESET[PHY_RESET] is set. */ + dlmx_phy_reset.u64 =csr_rd (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 )); + dlmx_phy_reset.s.phy_reset =1 ; +csr_wr (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 ), dlmx_phy_reset.u64); + +/* 2. If SGMII or QSGMII or RXAUI (i.e. if DLM0) set +* GSER(0)_DLM(0)_MPLL_EN[MPLL_EN] to one. +*/ + +/* 3. Set GSER(0)_DLM(0..2)_MPLL_MULTIPLIER[MPLL_MULTIPLIER] +* to the value in the preceding table, which is different +* than the desired setting prescribed by the HRM. +*/ + mpll_multiplier.u64 =csr_rd (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 )); + mpll_multiplier.s.mpll_multiplier = ref_clk_mult[ref_clk_sel]; +debug ("%s: Setting MPLL multiplier to %d\n" , __func__, + (int )mpll_multiplier.s.mpll_multiplier); +csr_wr (CVMX_GSERX_DLMX_MPLL_MULTIPLIER (qlm,0 ), mpll_multiplier.u64); +/* 5. Clear GSER0_DLM(1..2)_TEST_POWERDOWN. Configurations that only +* use DLM1 need not clear GSER0_DLM2_TEST_POWERDOWN +*/ + dlmx_test_powerdown.u64 =csr_rd (CVMX_GSERX_DLMX_TEST_POWERDOWN (qlm,0 )); + dlmx_test_powerdown.s.test_powerdown =0 ; +csr_wr (CVMX_GSERX_DLMX_TEST_POWERDOWN (qlm,0 ), dlmx_test_powerdown.u64); + +/* 6. Clear GSER0_DLM(1..2)_PHY_RESET. Configurations that use only +* need DLM1 need not clear GSER0_DLM2_PHY_RESET +*/ + dlmx_phy_reset.u64 =csr_rd (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 )); + dlmx_phy_reset.s.phy_reset =0 ; +csr_wr (CVMX_GSERX_DLMX_PHY_RESET (qlm,0 ), dlmx_phy_reset.u64); + +/* 6. Decrease MPLL_MULTIPLIER by one continually until it reaches +* the desired long-term setting, ensuring that each MPLL_MULTIPLIER +* value is constant for at least 1 msec before changing to the next +* value. The desired long-term setting is as indicated in HRM tables +* 21-1, 21-2, and 21-3. This is not required with the HRM +* sequence. +*/ +/* This is set when initializing PCIe after soft reset is asserted. */ + +/* 7. Write the GSER0_PCIE_PIPE_RST register to take the appropriate +* PIPE out of reset. There is a PIPEn_RST bit for each PIPE. Clear +* the appropriate bits based on the configuration (reset is +* active high). +*/ +if (qlm ==1 ) { +cvmx_pemx_cfg_t pemx_cfg; +cvmx_pemx_on_t pemx_on; +cvmx_gserx_pcie_pipe_rst_t pipe_rst; +cvmx_rst_ctlx_t rst_ctl; + +switch (mode) { +case CVMX_QLM_MODE_PCIE :/* PEM0 on DLM1 & DLM2 */ +case CVMX_QLM_MODE_PCIE_1X2 :/* PEM0 on DLM1 */ +case CVMX_QLM_MODE_PCIE_1X1 :/* PEM0 on DLM1 using lane 0 */ + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (0 )); + pemx_cfg.cn70xx.hostmd = rc; +if (mode ==CVMX_QLM_MODE_PCIE_1X1 ) { + pemx_cfg.cn70xx.md = + gen2 ?CVMX_PEM_MD_GEN2_1LANE :CVMX_PEM_MD_GEN1_1LANE ; + }else if (mode ==CVMX_QLM_MODE_PCIE ) { + pemx_cfg.cn70xx.md = + gen2 ?CVMX_PEM_MD_GEN2_4LANE :CVMX_PEM_MD_GEN1_4LANE ; + }else { + pemx_cfg.cn70xx.md = + gen2 ?CVMX_PEM_MD_GEN2_2LANE :CVMX_PEM_MD_GEN1_2LANE ; + } +csr_wr (CVMX_PEMX_CFG (0 ), pemx_cfg.u64); + + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (0 )); + rst_ctl.s.rst_drv =1 ; +csr_wr (CVMX_RST_CTLX (0 ), rst_ctl.u64); + +/* PEM0 is on DLM1&2 which is pipe0 */ + pipe_rst.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_RST (0 )); + pipe_rst.s.pipe0_rst =0 ; +csr_wr (CVMX_GSERX_PCIE_PIPE_RST (0 ), pipe_rst.u64); + + pemx_on.u64 =csr_rd (CVMX_PEMX_ON (0 )); + pemx_on.s.pemon =1 ; +csr_wr (CVMX_PEMX_ON (0 ), pemx_on.u64); +break ; +case CVMX_QLM_MODE_PCIE_2X1 :/* PEM0 and PEM1 on DLM1 */ + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (0 )); + pemx_cfg.cn70xx.hostmd = rc; + pemx_cfg.cn70xx.md = gen2 ?CVMX_PEM_MD_GEN2_1LANE :CVMX_PEM_MD_GEN1_1LANE ; +csr_wr (CVMX_PEMX_CFG (0 ), pemx_cfg.u64); + + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (0 )); + rst_ctl.s.rst_drv =1 ; +csr_wr (CVMX_RST_CTLX (0 ), rst_ctl.u64); + +/* PEM0 is on DLM1 which is pipe0 */ + pipe_rst.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_RST (0 )); + pipe_rst.s.pipe0_rst =0 ; +csr_wr (CVMX_GSERX_PCIE_PIPE_RST (0 ), pipe_rst.u64); + + pemx_on.u64 =csr_rd (CVMX_PEMX_ON (0 )); + pemx_on.s.pemon =1 ; +csr_wr (CVMX_PEMX_ON (0 ), pemx_on.u64); + + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (1 )); + pemx_cfg.cn70xx.hostmd =1 ; + pemx_cfg.cn70xx.md = gen2 ?CVMX_PEM_MD_GEN2_1LANE :CVMX_PEM_MD_GEN1_1LANE ; +csr_wr (CVMX_PEMX_CFG (1 ), pemx_cfg.u64); + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (1 )); + rst_ctl.s.rst_drv =1 ; +csr_wr (CVMX_RST_CTLX (1 ), rst_ctl.u64); +/* PEM1 is on DLM2 which is pipe1 */ + pipe_rst.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_RST (0 )); + pipe_rst.s.pipe1_rst =0 ; +csr_wr (CVMX_GSERX_PCIE_PIPE_RST (0 ), pipe_rst.u64); + pemx_on.u64 =csr_rd (CVMX_PEMX_ON (1 )); + pemx_on.s.pemon =1 ; +csr_wr (CVMX_PEMX_ON (1 ), pemx_on.u64); +break ; +default : +break ; + } + }else { +cvmx_pemx_cfg_t pemx_cfg; +cvmx_pemx_on_t pemx_on; +cvmx_gserx_pcie_pipe_rst_t pipe_rst; +cvmx_rst_ctlx_t rst_ctl; + +switch (mode) { +case CVMX_QLM_MODE_PCIE_1X2 :/* PEM1 on DLM2 */ + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (1 )); + pemx_cfg.cn70xx.hostmd =1 ; + pemx_cfg.cn70xx.md = gen2 ?CVMX_PEM_MD_GEN2_2LANE :CVMX_PEM_MD_GEN1_2LANE ; +csr_wr (CVMX_PEMX_CFG (1 ), pemx_cfg.u64); + + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (1 )); + rst_ctl.s.rst_drv =1 ; +csr_wr (CVMX_RST_CTLX (1 ), rst_ctl.u64); + +/* PEM1 is on DLM1 lane 0, which is pipe1 */ + pipe_rst.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_RST (0 )); + pipe_rst.s.pipe1_rst =0 ; +csr_wr (CVMX_GSERX_PCIE_PIPE_RST (0 ), pipe_rst.u64); + + pemx_on.u64 =csr_rd (CVMX_PEMX_ON (1 )); + pemx_on.s.pemon =1 ; +csr_wr (CVMX_PEMX_ON (1 ), pemx_on.u64); +break ; +case CVMX_QLM_MODE_PCIE_2X1 :/* PEM1 and PEM2 on DLM2 */ + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (1 )); + pemx_cfg.cn70xx.hostmd =1 ; + pemx_cfg.cn70xx.md = gen2 ?CVMX_PEM_MD_GEN2_1LANE :CVMX_PEM_MD_GEN1_1LANE ; +csr_wr (CVMX_PEMX_CFG (1 ), pemx_cfg.u64); + + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (1 )); + rst_ctl.s.rst_drv =1 ; +csr_wr (CVMX_RST_CTLX (1 ), rst_ctl.u64); + +/* PEM1 is on DLM2 lane 0, which is pipe2 */ + pipe_rst.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_RST (0 )); + pipe_rst.s.pipe2_rst =0 ; +csr_wr (CVMX_GSERX_PCIE_PIPE_RST (0 ), pipe_rst.u64); + + pemx_on.u64 =csr_rd (CVMX_PEMX_ON (1 )); + pemx_on.s.pemon =1 ; +csr_wr (CVMX_PEMX_ON (1 ), pemx_on.u64); + + pemx_cfg.u64 =csr_rd (CVMX_PEMX_CFG (2 )); + pemx_cfg.cn70xx.hostmd =1 ; + pemx_cfg.cn70xx.md = gen2 ?CVMX_PEM_MD_GEN2_1LANE :CVMX_PEM_MD_GEN1_1LANE ; +csr_wr (CVMX_PEMX_CFG (2 ), pemx_cfg.u64); + + rst_ctl.u64 =csr_rd (CVMX_RST_CTLX (2 )); + rst_ctl.s.rst_drv =1 ; +csr_wr (CVMX_RST_CTLX (2 ), rst_ctl.u64); + +/* PEM2 is on DLM2 lane 1, which is pipe3 */ + pipe_rst.u64 =csr_rd (CVMX_GSERX_PCIE_PIPE_RST (0 )); + pipe_rst.s.pipe3_rst =0 ; +csr_wr (CVMX_GSERX_PCIE_PIPE_RST (0 ), pipe_rst.u64); + + pemx_on.u64 =csr_rd (CVMX_PEMX_ON (2 )); + pemx_on.s.pemon =1 ; +csr_wr (CVMX_PEMX_ON (2 ), pemx_on.u64); +break ; +default : +break ; + } + } +return 0 ; +} + +/** +* Configure dlm speed and mode for cn70xx. +* +* @param qlm The DLM to configure +* @param speed The speed the DLM needs to be configured in Mhz. +* @param mode The DLM to be configured as SGMII/XAUI/PCIe. +* DLM 0: has 2 interfaces which can be configured as +* SGMII/QSGMII/RXAUI. Need to configure both at the +* same time. These are valid option +* CVMX_QLM_MODE_QSGMII, +* CVMX_QLM_MODE_SGMII_SGMII, +* CVMX_QLM_MODE_SGMII_DISABLED, +* CVMX_QLM_MODE_DISABLED_SGMII, +* CVMX_QLM_MODE_SGMII_QSGMII, +* CVMX_QLM_MODE_QSGMII_QSGMII, +* CVMX_QLM_MODE_QSGMII_DISABLED, +* CVMX_QLM_MODE_DISABLED_QSGMII, +* CVMX_QLM_MODE_QSGMII_SGMII, +* CVMX_QLM_MODE_RXAUI_1X2 +* +* DLM 1: PEM0/1 in PCIE_1x4/PCIE_2x1/PCIE_1X1 +* DLM 2: PEM0/1/2 in PCIE_1x4/PCIE_1x2/PCIE_2x1/PCIE_1x1 +* @param rc Only used for PCIe, rc = 1 for root complex mode, 0 for EP mode. +* @param gen2 Only used for PCIe, gen2 = 1, in GEN2 mode else in GEN1 mode. +* +* @param ref_clk_input The reference-clock input to use to configure QLM +* @param ref_clk_sel The reference-clock selection to use to configure QLM +* +* @return Return 0 on success or -1. +*/ +static int octeon_configure_qlm_cn70xx (int qlm,int speed,int mode,int rc,int gen2, +int ref_clk_sel,int ref_clk_input) +{ +debug ("%s(%d, %d, %d, %d, %d, %d, %d)\n" , __func__, qlm, speed, mode, rc, gen2, ref_clk_sel, + ref_clk_input); +switch (qlm) { +case 0 : { +int is_sff7000_rxaui =0 ; +cvmx_gmxx_inf_mode_t inf_mode0, inf_mode1; + + inf_mode0.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); + inf_mode1.u64 =csr_rd (CVMX_GMXX_INF_MODE (1 )); +if (inf_mode0.s.en || inf_mode1.s.en) { +debug ("DLM0 already configured\n" ); +return -1 ; + } + +switch (mode) { +case CVMX_QLM_MODE_SGMII_SGMII : +debug (" Mode SGMII SGMII\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_SGMII ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_SGMII ; +break ; +case CVMX_QLM_MODE_SGMII_QSGMII : +debug (" Mode SGMII QSGMII\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_SGMII ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_QSGMII ; +break ; +case CVMX_QLM_MODE_SGMII_DISABLED : +debug (" Mode SGMII Disabled\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_SGMII ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_DISABLED ; +break ; +case CVMX_QLM_MODE_DISABLED_SGMII : +debug ("Mode Disabled SGMII\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_DISABLED ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_SGMII ; +break ; +case CVMX_QLM_MODE_QSGMII_SGMII : +debug (" Mode QSGMII SGMII\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_QSGMII ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_SGMII ; +break ; +case CVMX_QLM_MODE_QSGMII_QSGMII : +debug (" Mode QSGMII QSGMII\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_QSGMII ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_QSGMII ; +break ; +case CVMX_QLM_MODE_QSGMII_DISABLED : +debug (" Mode QSGMII Disabled\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_QSGMII ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_DISABLED ; +break ; +case CVMX_QLM_MODE_DISABLED_QSGMII : +debug ("Mode Disabled QSGMII\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_DISABLED ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_QSGMII ; +break ; +case CVMX_QLM_MODE_RXAUI : +debug (" Mode RXAUI\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_RXAUI ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_DISABLED ; + +break ; +default : +debug (" Mode Disabled Disabled\n" ); + inf_mode0.s.mode =CVMX_GMX_INF_MODE_DISABLED ; + inf_mode1.s.mode =CVMX_GMX_INF_MODE_DISABLED ; +break ; + } +csr_wr (CVMX_GMXX_INF_MODE (0 ), inf_mode0.u64); +csr_wr (CVMX_GMXX_INF_MODE (1 ), inf_mode1.u64); + +/* Bringup the PLL */ +if (__dlm_setup_pll_cn70xx (qlm, speed, ref_clk_sel, ref_clk_input, + is_sff7000_rxaui)) +return -1 ; + +/* TX Lanes */ +if (__dlm0_setup_tx_cn70xx (speed, ref_clk_sel)) +return -1 ; + +/* RX Lanes */ +if (__dlm0_setup_rx_cn70xx (speed, ref_clk_sel)) +return -1 ; + +/* Enable the interface */ + inf_mode0.u64 =csr_rd (CVMX_GMXX_INF_MODE (0 )); +if (inf_mode0.s.mode !=CVMX_GMX_INF_MODE_DISABLED ) + inf_mode0.s.en =1 ; +csr_wr (CVMX_GMXX_INF_MODE (0 ), inf_mode0.u64); + inf_mode1.u64 =csr_rd (CVMX_GMXX_INF_MODE (1 )); +if (inf_mode1.s.mode !=CVMX_GMX_INF_MODE_DISABLED ) + inf_mode1.s.en =1 ; +csr_wr (CVMX_GMXX_INF_MODE (1 ), inf_mode1.u64); +break ; + } +case 1 : +switch (mode) { +case CVMX_QLM_MODE_PCIE :/* PEM0 on DLM1 & DLM2 */ +debug (" Mode PCIe\n" ); +if (__dlmx_setup_pcie_cn70xx (1 , mode, gen2, rc, ref_clk_sel, ref_clk_input)) +return -1 ; +if (__dlmx_setup_pcie_cn70xx (2 , mode, gen2, rc, ref_clk_sel, ref_clk_input)) +return -1 ; +break ; +case CVMX_QLM_MODE_PCIE_1X2 :/* PEM0 on DLM1 */ +case CVMX_QLM_MODE_PCIE_2X1 :/* PEM0 & PEM1 on DLM1 */ +case CVMX_QLM_MODE_PCIE_1X1 :/* PEM0 on DLM1, only 1 lane */ +debug (" Mode PCIe 1x2, 2x1 or 1x1\n" ); +if (__dlmx_setup_pcie_cn70xx (qlm, mode, gen2, rc, ref_clk_sel, + ref_clk_input)) +return -1 ; +break ; +case CVMX_QLM_MODE_DISABLED : +debug (" Mode disabled\n" ); +break ; +default : +debug ("DLM1 illegal mode specified\n" ); +return -1 ; + } +break ; +case 2 : +switch (mode) { +case CVMX_QLM_MODE_SATA_2X1 : +debug ("%s: qlm 2, mode is SATA 2x1\n" , __func__); +/* DLM2 is SATA, PCIE2 is disabled */ +if (__setup_sata (qlm, speed, ref_clk_sel, ref_clk_input)) +return -1 ; +break ; +case CVMX_QLM_MODE_PCIE : +debug (" Mode PCIe\n" ); +/* DLM2 is PCIE0, PCIE1-2 are disabled. */ +/* Do nothing, its initialized in DLM1 */ +break ; +case CVMX_QLM_MODE_PCIE_1X2 :/* PEM1 on DLM2 */ +case CVMX_QLM_MODE_PCIE_2X1 :/* PEM1 & PEM2 on DLM2 */ +debug (" Mode PCIe 1x2 or 2x1\n" ); +if (__dlmx_setup_pcie_cn70xx (qlm, mode, gen2, rc, ref_clk_sel, + ref_clk_input)) +return -1 ; +break ; +case CVMX_QLM_MODE_DISABLED : +debug (" Mode Disabled\n" ); +break ; +default : +debug ("DLM2 illegal mode specified\n" ); +return -1 ; + } +default : +return -1 ; + } + +return 0 ; +} + +/** +* Disables DFE for the specified QLM lane(s). +* This function should only be called for low-loss channels. +* +* @param node Node to configure +* @param qlm QLM to configure +* @param lane Lane to configure, or -1 all lanes +* @param baud_mhz The speed the QLM needs to be configured in Mhz. +* @param mode The QLM to be configured as SGMII/XAUI/PCIe. +*/ +void octeon_qlm_dfe_disable (int node,int qlm,int lane,int baud_mhz,int mode) +{ +int num_lanes =cvmx_qlm_get_lanes (qlm); +int l; +cvmx_gserx_lanex_rx_loop_ctrl_t loop_ctrl; +cvmx_gserx_lanex_rx_valbbd_ctrl_0_t ctrl_0; +cvmx_gserx_lanex_rx_valbbd_ctrl_1_t ctrl_1; +cvmx_gserx_lanex_rx_valbbd_ctrl_2_t ctrl_2; +cvmx_gserx_lane_vma_fine_ctrl_2_t lane_vma_fine_ctrl_2; + +/* Interfaces below 5Gbaud are already manually tuned. */ +if (baud_mhz <5000 ) +return ; + +/* Don't run on PCIe links, SATA or KR. These interfaces use training */ +switch (mode) { +case CVMX_QLM_MODE_10G_KR_1X2 : +case CVMX_QLM_MODE_10G_KR : +case CVMX_QLM_MODE_40G_KR4 : +return ; +case CVMX_QLM_MODE_PCIE_1X1 : +case CVMX_QLM_MODE_PCIE_2X1 : +case CVMX_QLM_MODE_PCIE_1X2 : +case CVMX_QLM_MODE_PCIE : +case CVMX_QLM_MODE_PCIE_1X8 : +return ; +case CVMX_QLM_MODE_SATA_2X1 : +return ; +default : +break ; + } + +/* Updating pre_ctle minimum to 0. This works best for short channels */ + lane_vma_fine_ctrl_2.u64 =csr_rd_node (node,CVMX_GSERX_LANE_VMA_FINE_CTRL_2 (qlm)); + lane_vma_fine_ctrl_2.s.rx_prectle_gain_min_fine =0 ; +csr_wr_node (node,CVMX_GSERX_LANE_VMA_FINE_CTRL_2 (qlm), lane_vma_fine_ctrl_2.u64); + +for (l =0 ; l < num_lanes; l++) { +if (lane !=-1 && lane != l) +continue ; + +/* 1. Write GSERX_LANEx_RX_LOOP_CTRL = 0x0270 +* (var "loop_ctrl" with bits 8 & 1 cleared). +* bit<1> dfe_en_byp = 1'b0 +*/ + loop_ctrl.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_LOOP_CTRL (l, qlm)); + loop_ctrl.s.cfg_rx_lctrl = loop_ctrl.s.cfg_rx_lctrl &0x3fd ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_LOOP_CTRL (l, qlm), loop_ctrl.u64); + +/* 2. Write GSERX_LANEx_RX_VALBBD_CTRL_1 = 0x0000 +* (var "ctrl1" with all bits cleared) +* bits<14:11> CFG_RX_DFE_C3_MVAL = 4'b0000 +* bit<10> CFG_RX_DFE_C3_MSGN = 1'b0 +* bits<9:6> CFG_RX_DFE_C2_MVAL = 4'b0000 +* bit<5> CFG_RX_DFE_C2_MSGN = 1'b0 +* bits<4:0> CFG_RX_DFE_C1_MVAL = 5'b00000 +*/ + ctrl_1.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_1 (l, qlm)); + ctrl_1.s.dfe_c3_mval =0 ; + ctrl_1.s.dfe_c3_msgn =0 ; + ctrl_1.s.dfe_c2_mval =0 ; + ctrl_1.s.dfe_c2_msgn =0 ; + ctrl_1.s.dfe_c2_mval =0 ; + ctrl_1.s.dfe_c1_mval =0 ; + ctrl_1.s.dfe_c1_msgn =0 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_1 (l, qlm), ctrl_1.u64); + +/* 3. Write GSERX_LANEx_RX_VALBBD_CTRL_0 = 0x2400 +* (var "ctrl0" with following bits set/cleared) +* bits<11:10> CFG_RX_DFE_GAIN = 0x1 +* bits<9:6> CFG_RX_DFE_C5_MVAL = 4'b0000 +* bit<5> CFG_RX_DFE_C5_MSGN = 1'b0 +* bits<4:1> CFG_RX_DFE_C4_MVAL = 4'b0000 +* bit<0> CFG_RX_DFE_C4_MSGN = 1'b0 +*/ + ctrl_0.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_0 (l, qlm)); + ctrl_0.s.dfe_gain =0x1 ; + ctrl_0.s.dfe_c5_mval =0 ; + ctrl_0.s.dfe_c5_msgn =0 ; + ctrl_0.s.dfe_c4_mval =0 ; + ctrl_0.s.dfe_c4_msgn =0 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_0 (l, qlm), ctrl_0.u64); + +/* 4. Write GSER(0..13)_LANE(0..3)_RX_VALBBD_CTRL_2 = 0x003F +* //enable DFE tap overrides +* bit<5> dfe_ovrd_en = 1 +* bit<4> dfe_c5_ovrd_val = 1 +* bit<3> dfe_c4_ovrd_val = 1 +* bit<2> dfe_c3_ovrd_val = 1 +* bit<1> dfe_c2_ovrd_val = 1 +* bit<0> dfe_c1_ovrd_val = 1 +*/ + ctrl_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_2 (l, qlm)); + ctrl_2.s.dfe_ovrd_en =0x1 ; + ctrl_2.s.dfe_c5_ovrd_val =0x1 ; + ctrl_2.s.dfe_c4_ovrd_val =0x1 ; + ctrl_2.s.dfe_c3_ovrd_val =0x1 ; + ctrl_2.s.dfe_c2_ovrd_val =0x1 ; + ctrl_2.s.dfe_c1_ovrd_val =0x1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_2 (l, qlm), ctrl_2.u64); + } +} + +/** +* Disables DFE, uses fixed CTLE Peak value and AGC settings +* for the specified QLM lane(s). +* This function should only be called for low-loss channels. +* This function prevents Rx equalization from happening on all lanes in a QLM +* This function should be called for all lanes being used in the QLM. +* +* @param node Node to configure +* @param qlm QLM to configure +* @param lane Lane to configure, or -1 all lanes +* @param baud_mhz The speed the QLM needs to be configured in Mhz. +* @param mode The QLM to be configured as SGMII/XAUI/PCIe. +* @param ctle_zero Equalizer Peaking control +* @param agc_pre_ctle Pre-CTLE gain +* @param agc_post_ctle Post-CTLE gain +* @return Zero on success, negative on failure +*/ + +int octeon_qlm_dfe_disable_ctle_agc (int node,int qlm,int lane,int baud_mhz,int mode, +int ctle_zero,int agc_pre_ctle,int agc_post_ctle) +{ +int num_lanes =cvmx_qlm_get_lanes (qlm); +int l; +cvmx_gserx_lanex_rx_loop_ctrl_t loop_ctrl; +cvmx_gserx_lanex_rx_valbbd_ctrl_0_t ctrl_0; +cvmx_gserx_lanex_pwr_ctrl_t lanex_pwr_ctrl; +cvmx_gserx_lane_mode_t lmode; +cvmx_gserx_lane_px_mode_1_t px_mode_1; +cvmx_gserx_lanex_rx_cfg_5_t rx_cfg_5; +cvmx_gserx_lanex_rx_cfg_2_t rx_cfg_2; +cvmx_gserx_lanex_rx_ctle_ctrl_t ctle_ctrl; + +/* Check tuning constraints */ +if (ctle_zero <0 || ctle_zero >15 ) { +printf ("Error: N%d.QLM%d: Invalid CTLE_ZERO(%d). Must be between -1 and 15.\n" , + node, qlm, ctle_zero); +return -1 ; + } +if (agc_pre_ctle <0 || agc_pre_ctle >15 ) { +printf ("Error: N%d.QLM%d: Invalid AGC_Pre_CTLE(%d)\n" , + node, qlm, agc_pre_ctle); +return -1 ; + } + +if (agc_post_ctle <0 || agc_post_ctle >15 ) { +printf ("Error: N%d.QLM%d: Invalid AGC_Post_CTLE(%d)\n" , + node, qlm, agc_post_ctle); +return -1 ; + } + +/* Interfaces below 5Gbaud are already manually tuned. */ +if (baud_mhz <5000 ) +return 0 ; + +/* Don't run on PCIe links, SATA or KR. These interfaces use training */ +switch (mode) { +case CVMX_QLM_MODE_10G_KR_1X2 : +case CVMX_QLM_MODE_10G_KR : +case CVMX_QLM_MODE_40G_KR4 : +return 0 ; +case CVMX_QLM_MODE_PCIE_1X1 : +case CVMX_QLM_MODE_PCIE_2X1 : +case CVMX_QLM_MODE_PCIE_1X2 : +case CVMX_QLM_MODE_PCIE : +case CVMX_QLM_MODE_PCIE_1X8 : +return 0 ; +case CVMX_QLM_MODE_SATA_2X1 : +return 0 ; +default : +break ; + } + + lmode.u64 =csr_rd_node (node,CVMX_GSERX_LANE_MODE (qlm)); + +/* 1. Enable VMA manual mode for the QLM's lane mode */ + px_mode_1.u64 =csr_rd_node (node,CVMX_GSERX_LANE_PX_MODE_1 (lmode.s.lmode, qlm)); + px_mode_1.s.vma_mm =1 ; +csr_wr_node (node,CVMX_GSERX_LANE_PX_MODE_1 (lmode.s.lmode, qlm), px_mode_1.u64); + +/* 2. Disable DFE */ +octeon_qlm_dfe_disable (node, qlm, lane, baud_mhz, mode); + +for (l =0 ; l < num_lanes; l++) { +if (lane !=-1 && lane != l) +continue ; + +/* 3. Write GSERX_LANEx_RX_VALBBD_CTRL_0.CFG_RX_AGC_GAIN = 0x2 */ + ctrl_0.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_0 (l, qlm)); + ctrl_0.s.agc_gain =0x2 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_VALBBD_CTRL_0 (l, qlm), ctrl_0.u64); + +/* 4. Write GSERX_LANEx_RX_LOOP_CTRL +* bit<8> lctrl_men = 1'b1 +* bit<0> cdr_en_byp = 1'b1 +*/ + loop_ctrl.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_LOOP_CTRL (l, qlm)); + loop_ctrl.s.cfg_rx_lctrl = loop_ctrl.s.cfg_rx_lctrl |0x101 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_LOOP_CTRL (l, qlm), loop_ctrl.u64); + +/* 5. Write GSERX_LANEx_PWR_CTRL = 0x0040 (var "lanex_pwr_ctrl" with +* following bits set) +* bit<6> RX_LCTRL_OVRRD_EN = 1'b1 +* all other bits cleared. +*/ + lanex_pwr_ctrl.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PWR_CTRL (l, qlm)); + lanex_pwr_ctrl.s.rx_lctrl_ovrrd_en =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PWR_CTRL (l, qlm), lanex_pwr_ctrl.u64); + +/* --Setting AGC in manual mode and configuring CTLE-- */ + rx_cfg_5.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_CFG_5 (l, qlm)); + rx_cfg_5.s.rx_agc_men_ovrrd_val =1 ; + rx_cfg_5.s.rx_agc_men_ovrrd_en =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_CFG_5 (l, qlm), rx_cfg_5.u64); + + ctle_ctrl.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_CTLE_CTRL (l, qlm)); + ctle_ctrl.s.pcs_sds_rx_ctle_zero = ctle_zero; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_CTLE_CTRL (l, qlm), ctle_ctrl.u64); + + rx_cfg_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_CFG_2 (l, qlm)); + rx_cfg_2.s.rx_sds_rx_agc_mval = (agc_pre_ctle <<4 ) | agc_post_ctle; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_CFG_2 (l, qlm), rx_cfg_2.u64); + } +return 0 ; +} + +/** +* Some QLM speeds need to override the default tuning parameters +* +* @param node Node to configure +* @param qlm QLM to configure +* @param baud_mhz Desired speed in MHz +* @param lane Lane the apply the tuning parameters +* @param tx_swing Voltage swing. The higher the value the lower the voltage, +* the default value is 7. +* @param tx_pre pre-cursor pre-emphasis +* @param tx_post post-cursor pre-emphasis. +* @param tx_gain Transmit gain. Range 0-7 +* @param tx_vboost Transmit voltage boost. Range 0-1 +*/ +void octeon_qlm_tune_per_lane_v3 (int node,int qlm,int baud_mhz,int lane,int tx_swing, +int tx_pre,int tx_post,int tx_gain,int tx_vboost) +{ +cvmx_gserx_cfg_t gserx_cfg; +cvmx_gserx_lanex_tx_cfg_0_t tx_cfg0; +cvmx_gserx_lanex_tx_pre_emphasis_t pre_emphasis; +cvmx_gserx_lanex_tx_cfg_1_t tx_cfg1; +cvmx_gserx_lanex_tx_cfg_3_t tx_cfg3; +cvmx_bgxx_spux_br_pmd_control_t pmd_control; +cvmx_gserx_lanex_pcs_ctlifc_0_t pcs_ctlifc_0; +cvmx_gserx_lanex_pcs_ctlifc_2_t pcs_ctlifc_2; +int bgx, lmac; + +/* Do not apply QLM tuning to PCIe and KR interfaces. */ + gserx_cfg.u64 =csr_rd_node (node,CVMX_GSERX_CFG (qlm)); +if (gserx_cfg.s.pcie) +return ; + +/* Apply the QLM tuning only to cn73xx and cn78xx models only */ +if (OCTEON_IS_MODEL (OCTEON_CN78XX )) + bgx = (qlm <2 ) ? qlm : (qlm -2 ); +else if (OCTEON_IS_MODEL (OCTEON_CN73XX )) + bgx = (qlm <4 ) ? (qlm -2 ) :2 ; +else if (OCTEON_IS_MODEL (OCTEON_CNF75XX )) + bgx =0 ; +else +return ; + +if ((OCTEON_IS_MODEL (OCTEON_CN73XX ) && qlm ==6 ) || + (OCTEON_IS_MODEL (OCTEON_CNF75XX ) && qlm ==5 )) + lmac =2 ; +else + lmac = lane; + +/* No need to tune 10G-KR and 40G-KR interfaces */ + pmd_control.u64 =csr_rd_node (node,CVMX_BGXX_SPUX_BR_PMD_CONTROL (lmac, bgx)); +if (pmd_control.s.train_en) +return ; + +if (tx_pre !=-1 && tx_post ==-1 ) + tx_post =0 ; + +if (tx_post !=-1 && tx_pre ==-1 ) + tx_pre =0 ; + +/* Check tuning constraints */ +if (tx_swing <-1 || tx_swing >25 ) { +printf ("ERROR: N%d:QLM%d: Lane %d: Invalid TX_SWING(%d). TX_SWING must be <= 25.\n" , + node, qlm, lane, tx_swing); +return ; + } + +if (tx_pre <-1 || tx_pre >10 ) { +printf ("ERROR: N%d:QLM%d: Lane %d: Invalid TX_PRE(%d). TX_PRE must be <= 10.\n" , + node, qlm, lane, tx_swing); +return ; + } + +if (tx_post <-1 || tx_post >31 ) { +printf ("ERROR: N%d:QLM%d: Lane %d: Invalid TX_POST(%d). TX_POST must be <= 15.\n" , + node, qlm, lane, tx_swing); +return ; + } + +if (tx_pre >=0 && tx_post >=0 && tx_swing >=0 && + tx_pre + tx_post - tx_swing >2 ) { +printf ("ERROR: N%d.QLM%d: Lane %d: TX_PRE(%d) + TX_POST(%d) - TX_SWING(%d) must be <= 2\n" , + node, qlm, lane, tx_pre, tx_post, tx_swing); +return ; + } + +if (tx_pre >=0 && tx_post >=0 && tx_swing >=0 && + tx_pre + tx_post + tx_swing >35 ) { +printf ("ERROR: N%d.QLM%d: Lane %d: TX_PRE(%d) + TX_POST(%d) + TX_SWING(%d) must be <= 35\n" , + node, qlm, lane, tx_pre, tx_post, tx_swing); +return ; + } + +if (tx_gain <-1 || tx_gain >7 ) { +printf ("ERROR: N%d.QLM%d: Lane %d: Invalid TX_GAIN(%d). TX_GAIN must be between 0 and 7\n" , + node, qlm, lane, tx_gain); +return ; + } + +if (tx_vboost <-1 || tx_vboost >1 ) { +printf ("ERROR: N%d.QLM%d: Lane %d: Invalid TX_VBOOST(%d). TX_VBOOST must be 0 or 1.\n" , + node, qlm, lane, tx_vboost); +return ; + } + +debug ("N%d.QLM%d: Lane %d: TX_SWING=%d, TX_PRE=%d, TX_POST=%d, TX_GAIN=%d, TX_VBOOST=%d\n" , + node, qlm, lane, tx_swing, tx_pre, tx_post, tx_gain, tx_vboost); + +/* Complete the Tx swing and Tx equilization programming */ +/* 1) Enable Tx swing and Tx emphasis overrides */ + tx_cfg1.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_TX_CFG_1 (lane, qlm)); + tx_cfg1.s.tx_swing_ovrrd_en = (tx_swing !=-1 ); + tx_cfg1.s.tx_premptap_ovrrd_val = (tx_pre !=-1 ) && (tx_post !=-1 ); + tx_cfg1.s.tx_vboost_en_ovrrd_en = (tx_vboost !=-1 );/* Vboost override */ + ; +csr_wr_node (node,CVMX_GSERX_LANEX_TX_CFG_1 (lane, qlm), tx_cfg1.u64); +/* 2) Program the Tx swing and Tx emphasis Pre-cursor and Post-cursor values */ +/* CFG_TX_PREMPTAP[8:4] = Lane X's TX post-cursor value (C+1) */ +/* CFG_TX_PREMPTAP[3:0] = Lane X's TX pre-cursor value (C-1) */ +if (tx_swing !=-1 ) { + tx_cfg0.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_TX_CFG_0 (lane, qlm)); + tx_cfg0.s.cfg_tx_swing = tx_swing; +csr_wr_node (node,CVMX_GSERX_LANEX_TX_CFG_0 (lane, qlm), tx_cfg0.u64); + } + +if ((tx_pre !=-1 ) && (tx_post !=-1 )) { + pre_emphasis.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_TX_PRE_EMPHASIS (lane, qlm)); + pre_emphasis.s.cfg_tx_premptap = (tx_post <<4 ) | tx_pre; +csr_wr_node (node,CVMX_GSERX_LANEX_TX_PRE_EMPHASIS (lane, qlm), pre_emphasis.u64); + } + +/* Apply TX gain settings */ +if (tx_gain !=-1 ) { + tx_cfg3.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_TX_CFG_3 (lane, qlm)); + tx_cfg3.s.pcs_sds_tx_gain = tx_gain; +csr_wr_node (node,CVMX_GSERX_LANEX_TX_CFG_3 (lane, qlm), tx_cfg3.u64); + } + +/* Apply TX vboot settings */ +if (tx_vboost !=-1 ) { + tx_cfg3.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_TX_CFG_3 (lane, qlm)); + tx_cfg3.s.cfg_tx_vboost_en = tx_vboost; +csr_wr_node (node,CVMX_GSERX_LANEX_TX_CFG_3 (lane, qlm), tx_cfg3.u64); + } + +/* 3) Program override for the Tx coefficient request */ + pcs_ctlifc_0.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_0 (lane, qlm)); +if (((tx_pre !=-1 ) && (tx_post !=-1 )) || (tx_swing !=-1 )) + pcs_ctlifc_0.s.cfg_tx_coeff_req_ovrrd_val =0x1 ; +if (tx_vboost !=-1 ) + pcs_ctlifc_0.s.cfg_tx_vboost_en_ovrrd_val =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_0 (lane, qlm), pcs_ctlifc_0.u64); + +/* 4) Enable the Tx coefficient request override enable */ + pcs_ctlifc_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); +if (((tx_pre !=-1 ) && (tx_post !=-1 )) || (tx_swing !=-1 )) + pcs_ctlifc_2.s.cfg_tx_coeff_req_ovrrd_en =0x1 ; +if (tx_vboost !=-1 ) + pcs_ctlifc_2.s.cfg_tx_vboost_en_ovrrd_en =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), pcs_ctlifc_2.u64); + +/* 5) Issue a Control Interface Configuration Override request to start the Tx equalizer */ + pcs_ctlifc_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + pcs_ctlifc_2.s.ctlifc_ovrrd_req =0x1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), pcs_ctlifc_2.u64); + +/* 6) Wait 1 ms for the request to complete */ +udelay (1000 ); + +/* Steps 7 & 8 required for subsequent Tx swing and Tx equilization adjustment */ +/* 7) Disable the Tx coefficient request override enable */ + pcs_ctlifc_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + pcs_ctlifc_2.s.cfg_tx_coeff_req_ovrrd_en =0 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), pcs_ctlifc_2.u64); +/* 8) Issue a Control Interface Configuration Override request */ + pcs_ctlifc_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + pcs_ctlifc_2.s.ctlifc_ovrrd_req =0x1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), pcs_ctlifc_2.u64); +} + +/** +* Some QLM speeds need to override the default tuning parameters +* +* @param node Node to configure +* @param qlm QLM to configure +* @param baud_mhz Desired speed in MHz +* @param tx_swing Voltage swing. The higher the value the lower the voltage, +* the default value is 7. +* @param tx_premptap bits [0:3] pre-cursor pre-emphasis, bits[4:8] post-cursor +* pre-emphasis. +* @param tx_gain Transmit gain. Range 0-7 +* @param tx_vboost Transmit voltage boost. Range 0-1 +* +*/ +void octeon_qlm_tune_v3 (int node,int qlm,int baud_mhz,int tx_swing,int tx_premptap,int tx_gain, +int tx_vboost) +{ +int lane; +int num_lanes =cvmx_qlm_get_lanes (qlm); + +for (lane =0 ; lane < num_lanes; lane++) { +int tx_pre = (tx_premptap ==-1 ) ?-1 : tx_premptap &0xf ; +int tx_post = (tx_premptap ==-1 ) ?-1 : (tx_premptap >>4 ) &0x1f ; + +octeon_qlm_tune_per_lane_v3 (node, qlm, baud_mhz, lane, tx_swing, tx_pre, tx_post, + tx_gain, tx_vboost); + } +} + +/** +* Some QLMs need to override the default pre-ctle for low loss channels. +* +* @param node Node to configure +* @param qlm QLM to configure +* @param pre_ctle pre-ctle settings for low loss channels +*/ +void octeon_qlm_set_channel_v3 (int node,int qlm,int pre_ctle) +{ +cvmx_gserx_lane_vma_fine_ctrl_2_t lane_vma_fine_ctrl_2; + + lane_vma_fine_ctrl_2.u64 =csr_rd_node (node,CVMX_GSERX_LANE_VMA_FINE_CTRL_2 (qlm)); + lane_vma_fine_ctrl_2.s.rx_prectle_gain_min_fine = pre_ctle; +csr_wr_node (node,CVMX_GSERX_LANE_VMA_FINE_CTRL_2 (qlm), lane_vma_fine_ctrl_2.u64); +} + +static void __qlm_init_errata_20844 (int node,int qlm) +{ +int lane; + +/* Only applies to CN78XX pass 1.x */ +if (!OCTEON_IS_MODEL (OCTEON_CN78XX_PASS1_0 )) +return ; + +/* Errata GSER-20844: Electrical Idle logic can coast +* 1) After the link first comes up write the following +* register on each lane to prevent the application logic +* from stomping on the Coast inputs. This is a one time write, +* or if you prefer you could put it in the link up loop and +* write it every time the link comes up. +* 1a) Then write GSER(0..13)_LANE(0..3)_PCS_CTLIFC_2 +* Set CTLIFC_OVRRD_REQ (later) +* Set CFG_RX_CDR_COAST_REQ_OVRRD_EN +* Its not clear if #1 and #1a can be combined, lets try it +* this way first. +*/ +for (lane =0 ; lane <4 ; lane++) { +cvmx_gserx_lanex_rx_misc_ovrrd_t misc_ovrrd; +cvmx_gserx_lanex_pcs_ctlifc_2_t ctlifc_2; + + ctlifc_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + ctlifc_2.s.cfg_rx_cdr_coast_req_ovrrd_en =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), ctlifc_2.u64); + + misc_ovrrd.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_MISC_OVRRD (lane, qlm)); + misc_ovrrd.s.cfg_rx_eie_det_ovrrd_en =1 ; + misc_ovrrd.s.cfg_rx_eie_det_ovrrd_val =0 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_MISC_OVRRD (lane, qlm), misc_ovrrd.u64); + +udelay (1 ); + + misc_ovrrd.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_RX_MISC_OVRRD (lane, qlm)); + misc_ovrrd.s.cfg_rx_eie_det_ovrrd_en =1 ; + misc_ovrrd.s.cfg_rx_eie_det_ovrrd_val =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_RX_MISC_OVRRD (lane, qlm), misc_ovrrd.u64); + ctlifc_2.u64 =csr_rd_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm)); + ctlifc_2.s.ctlifc_ovrrd_req =1 ; +csr_wr_node (node,CVMX_GSERX_LANEX_PCS_CTLIFC_2 (lane, qlm), ctlifc_2.u64); + } +} + +/** CN78xx reference clock register settings */ +struct refclk_settings_cn78xx { +bool valid;/** Reference clock speed supported */ +union cvmx_gserx_pll_px_mode_0 mode_0; +union cvmx_gserx_pll_px_mode_1 mode_1; +union cvmx_gserx_lane_px_mode_0 pmode_0; +union cvmx_gserx_lane_px_mode_1 pmode_1; +}; + +/** Default reference clock for various modes */ +static const u8 def_ref_clk_cn78xx[R_NUM_LANE_MODES ] = {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }; + +/** +* This data structure stores the reference clock for each mode for each QLM. +* +* It is indexed first by the node number, then the QLM number and then the +* lane mode. It is initialized to the default values. +*/ +static u8 ref_clk_cn78xx[CVMX_MAX_NODES ][8 ][R_NUM_LANE_MODES ] = { + { {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 } }, + { {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 } }, + { {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 } }, + { {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 }, + {0 ,0 ,0 ,2 ,2 ,2 ,2 ,2 ,2 ,1 ,1 ,1 } } +}; + +/** +* This data structure contains the register values for the cn78xx PLLs +* It is indexed first by the reference clock and second by the mode. +* Note that not all combinations are supported. +*/ +static const struct refclk_settings_cn78xx refclk_settings_cn78xx[R_NUM_LANE_MODES ][4 ] = { + {/* 0 R_2_5G_REFCLK100 */ + {/* 100MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x4 , .pll_rloop =0x3 , .pll_pcs_div =0x5 }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x19 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x1 , + .tx_ldiv =0x1 , + .rx_ldiv =0x1 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xa , + .ph_acc_adj =0x14 } }, + {/* 125MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x3 , .pll_rloop =0x3 , .pll_pcs_div =0x5 }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x1 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x14 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x1 , + .tx_ldiv =0x1 , + .rx_ldiv =0x1 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xa , + .ph_acc_adj =0x14 } }, + {/* 156.25MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x3 , .pll_rloop =0x3 , .pll_pcs_div =0x5 }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x10 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x1 , + .tx_ldiv =0x1 , + .rx_ldiv =0x1 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xa , + .ph_acc_adj =0x14 } }, + { +/* 161.1328125MHz reference clock */ + .valid = false, + } }, + { +/* 1 R_5G_REFCLK100 */ + {/* 100MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x4 , .pll_rloop =0x3 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x19 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x1 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x0 , + .cdr_fgain =0xa , + .ph_acc_adj =0x14 } }, + {/* 125MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x3 , .pll_rloop =0x3 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x1 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x14 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x1 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x0 , + .cdr_fgain =0xa , + .ph_acc_adj =0x14 } }, + {/* 156.25MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x3 , .pll_rloop =0x3 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x10 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x1 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x0 , + .cdr_fgain =0xa , + .ph_acc_adj =0x14 } }, + { +/* 161.1328125MHz reference clock */ + .valid = false, + }, + }, + {/* 2 R_8G_REFCLK100 */ + {/* 100MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x3 , .pll_rloop =0x5 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x1 , + .pll_opr =0x1 , + .pll_div =0x28 }, + .pmode_0.s = { .ctle =0x3 , + .pcie =0x0 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x0 , + .cdr_fgain =0xb , + .ph_acc_adj =0x23 } }, + {/* 125MHz reference clock */ + .valid = true, + .mode_0.s = { .pll_icp =0x2 , .pll_rloop =0x5 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x0 , + .pll_cpadj =0x1 , + .pll_pcie3en =0x1 , + .pll_opr =0x1 , + .pll_div =0x20 }, + .pmode_0.s = { .ctle =0x3 , + .pcie =0x0 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x0 , + .cdr_fgain =0xb , + .ph_acc_adj =0x23 } }, + {/* 156.25MHz reference clock not supported */ + .valid = false } }, + { +/* 3 R_125G_REFCLK15625_KX */ + {/* 100MHz reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x28 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x19 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x2 , + .rx_ldiv =0x2 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + {/* 125MHz reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x28 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x14 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x2 , + .rx_ldiv =0x2 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + {/* 156.25MHz reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x28 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x3 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x10 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x2 , + .rx_ldiv =0x2 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + { +/* 161.1328125MHz reference clock */ + .valid = false, + }, + }, + {/* 4 R_3125G_REFCLK15625_XAUI */ + {/* 100MHz reference */ + .valid = false }, + {/* 125MHz reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x14 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x19 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x1 , + .rx_ldiv =0x1 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + {/* 156.25MHz reference, default */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x14 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x14 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x1 , + .rx_ldiv =0x1 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + { +/* 161.1328125MHz reference clock */ + .valid = false, + } }, + {/* 5 R_103125G_REFCLK15625_KR */ + {/* 100MHz reference */ + .valid = false }, + {/* 125MHz reference */ + .valid = false }, + {/* 156.25MHz reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x5 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x1 , + .pll_div =0x21 }, + .pmode_0.s = { .ctle =0x3 , + .pcie =0x0 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x1 , + .vma_mm =0x0 , + .cdr_fgain =0xa , + .ph_acc_adj =0xf } }, + {/* 161.1328125 reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x5 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x1 , + .pll_div =0x20 }, + .pmode_0.s = { .ctle =0x3 , + .pcie =0x0 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x1 , + .vma_mm =0x0 , + .cdr_fgain =0xa , + .ph_acc_adj =0xf } } }, + {/* 6 R_125G_REFCLK15625_SGMII */ + {/* 100MHz reference clock */ + .valid =1 , + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x28 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x19 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x2 , + .rx_ldiv =0x2 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + {/* 125MHz reference clock */ + .valid =1 , + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x28 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x2 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x14 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x2 , + .rx_ldiv =0x2 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x0 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } }, + {/* 156.25MHz reference clock */ + .valid =1 , + .mode_0.s = { .pll_icp =0x1 , .pll_rloop =0x3 , .pll_pcs_div =0x28 }, + .mode_1.s = { .pll_16p5en =0x1 , + .pll_cpadj =0x3 , + .pll_pcie3en =0x0 , + .pll_opr =0x0 , + .pll_div =0x10 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x2 , + .rx_ldiv =0x2 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 , + .cdr_fgain =0xc , + .ph_acc_adj =0x1e } } }, + {/* 7 R_5G_REFCLK15625_QSGMII */ + {/* 100MHz reference */ + .valid = true, + .mode_0.s = { .pll_icp =0x4 , .pll_rloop =0x3 , .pll_pcs_div =0xa }, + .mode_1.s = { .pll_16p5en =0x0 , .pll_cpadj =0x2 , .pll_pcie3en =0x0 , + .pll_div =0x19 }, + .pmode_0.s = { .ctle =0x0 , + .pcie =0x0 , + .tx_ldiv =0x0 , + .rx_ldiv =0x0 , + .srate =0x0 , + .tx_mode =0x3 , + .rx_mode =0x3 }, + .pmode_1.s = { .vma_fine_cfg_sel =0x0 , + .vma_mm =0x1 ,
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.29.2
Part of the diff is not shown here. View the raw message.
PATCH 45/50 mips: octeon: Makefile: Enable building of the newly added C files
In reply to Stefan RoeseThis patch adds the newly added C files to the Makefile to enable compilation. This is done in a separate step, to not introduce build breakage while adding the single files with potentially missing externals.
---
arch/mips/mach-octeon/Makefile | 11 +++++++++++ 1 file changed, 11 insertions(+)
arch/mips/mach-octeon/Makefile +11 -0
@@ -11,3 +11,14 @@ obj-y += dram.o obj-y += cvmx-coremask.o obj-y += cvmx-bootmem.o obj-y += bootoctlinux.o + +# QLM related code +obj-y += cvmx-helper-cfg.o +obj-y += cvmx-helper-fdt.o +obj-y += cvmx-helper-jtag.o +obj-y += cvmx-helper-util.o +obj-y += cvmx-helper.o +obj-y += cvmx-pcie.o +obj-y += cvmx-qlm.o +obj-y += octeon_fdt.o +obj-y += octeon_qlm.o
Signature · 1 line
2.29.2
PATCH 46/50 mips: octeon: Kconfig: Enable CONFIG_SYS_PCI_64BIT
In reply to Stefan RoeseSetting CONFIG_SYS_PCI_64BIT is needed for correct PCIe functionality on MIPS Octeon.
---
arch/mips/mach-octeon/Kconfig | 4 ++++ 1 file changed, 4 insertions(+)
arch/mips/mach-octeon/Kconfig +4 -0
@@ -55,6 +55,10 @@ config SYS_ICACHE_SIZE config SYS_ICACHE_LINE_SIZE default 128 +config SYS_PCI_64BIT + bool + default y + source "board/Marvell/octeon_ebb7304/Kconfig" endmenu
Signature · 1 line
2.29.2
PATCH 47/50 mips: octeon: mrvl, cn73xx.dtsi: Add PCIe controller DT node
In reply to Stefan RoeseThis patch adds the PCIe controller node to the MIPS Octeon 73xx dtsi file.
---
arch/mips/dts/mrvl,cn73xx.dtsi | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
arch/mips/dts/mrvl,cn73xx.dtsi +16 -0
@@ -203,5 +203,21 @@ dr_mode = "host"; }; }; + + /* PCIe 0 */ + pcie0: pcie at 1180069000000 { + compatible = "marvell,pcie-host-octeon"; + reg = <0 0xf2600000 0 0x10000>; + #address-cells = <3>; + #size-cells = <2>; + device_type = "pci"; + dma-coherent; + + bus-range = <0 0xff>; + marvell,pcie-port = <0>; + ranges = <0x81000000 0x00000000 0xd0000000 0x00011a00 0xd0000000 0x00000000 0x01000000 /* IO */ + 0x02000000 0x00000000 0xe0000000 0x00011b00 0xe0000000 0x00000000 0x10000000 /* non-prefetchable memory */ + 0x43000000 0x00011c00 0x00000000 0x00011c00 0x00000000 0x00000010 0x00000000>;/* prefetchable memory */ + }; }; };
Signature · 1 line
2.29.2
PATCH 48/50 mips: octeon: octeon_ebb7304: Add board specific QLM init code
In reply to Stefan RoeseFrom: Aaron Williams <[email protected]>
This patch adds the board specific QLM/DLM init code to the Octeon 3 EBB7304 board. The configuration of each port is read from the environment exactly as done in the 2013 U-Boot version to keep the board and it's configuration compatible.
---
board/Marvell/octeon_ebb7304/board.c | 732 ++++++++++++++++++++++++++- 1 file changed, 730 insertions(+), 2 deletions(-)
board/Marvell/octeon_ebb7304/board.c +730 -2
@@ -3,20 +3,32 @@* Copyright (C) 2020 Stefan Roese <[email protected]> */ -#include <common.h> #include <dm.h> +#include <fdt_support.h> #include <ram.h> +#include <asm/gpio.h> #include <mach/octeon_ddr.h> +#include <mach/cvmx-qlm.h> +#include <mach/octeon_qlm.h> +#include <mach/octeon_fdt.h> +#include <mach/cvmx-helper.h> +#include <mach/cvmx-helper-cfg.h> +#include <mach/cvmx-helper-util.h> +#include <mach/cvmx-bgxx-defs.h> #include "board_ddr.h" +#define MAX_MIX_ENV_VARS 4 +#define EBB7304_DEF_DRAM_FREQ 800static struct ddr_conf board_ddr_conf[] = { -OCTEON_EBB7304_DDR_CONFIGURATION +OCTEON_EBB7304_DDR_CONFIGURATION }; +static int no_phy[8 ] = {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +struct ddr_conf *octeon_ddr_conf_table_get (int *count,int *def_ddr_freq) { *count =ARRAY_SIZE (board_ddr_conf);
@@ -24,3 +36,719 @@ struct ddr_conf *octeon_ddr_conf_table_get(int *count, int *def_ddr_freq)return board_ddr_conf; } + +/* +* parse_env_var: Parse the environment variable ("bgx_for_mix%d") to +* extract the lmac it is set to. +* +* index: Index of environment variable to parse. +* environment variable. +* env_bgx: Updated with the bgx of the lmac in the environment +* variable. +* env_lmac: Updated with the index of lmac in the environment +* variable. +* +* returns: Zero on success, error otherwise. +*/ +static int parse_env_var (int index,int *env_bgx,int *env_lmac) +{ +char env_var[20 ]; +ulong xipd_port; + +sprintf (env_var,"bgx_for_mix%d" , index); + xipd_port =env_get_ulong (env_var,0 ,0xffff ); +if (xipd_port !=0xffff ) { +int xiface; +struct cvmx_xiface xi; +struct cvmx_xport xp; + +/* +* The environemt variable is set to the xipd port. Convert the +* xipd port to numa node, bgx, and lmac. +*/ + xiface =cvmx_helper_get_interface_num (xipd_port); + xi =cvmx_helper_xiface_to_node_interface (xiface); + xp =cvmx_helper_ipd_port_to_xport (xipd_port); + *env_bgx = xi.interface; + *env_lmac =cvmx_helper_get_interface_index_num (xp.port); +return 0 ; + } + +return -1 ; +} + +/* +* get_lmac_fdt_node: Search the device tree for the node corresponding to +* a given bgx lmac. +* +* fdt: Pointer to flat device tree +* search_node: Numa node of the lmac to search for. +* search_bgx: Bgx of the lmac to search for. +* search_lmac: Lmac index to search for. +* compat: Compatible string to search for. + +* returns: The device tree node of the lmac if found, +* or -1 otherwise. +*/ +static int get_lmac_fdt_node (const void *fdt,int search_node,int search_bgx,int search_lmac, +const char *compat) +{ +int node; +const fdt32_t *reg; +u64 addr; +int fdt_node =-1 ; +int fdt_bgx =-1 ; +int fdt_lmac =-1 ; +int len; +int parent; + +/* Iterate through all bgx ports */ + node =-1 ; +while ((node =fdt_node_offset_by_compatible ((void *)fdt, node, + compat)) >=0 ) { +/* Get the node and bgx from the physical address */ + parent =fdt_parent_offset (fdt, node); + reg =fdt_getprop (fdt, parent,"reg" , &len); +if (parent <0 || !reg) +continue ; + + addr =fdt_translate_address ((void *)fdt, parent, reg); + fdt_node = (addr >>36 ) &0x7 ; + fdt_bgx = (addr >>24 ) &0xf ; + +/* Get the lmac index from the reg property */ + reg =fdt_getprop (fdt, node,"reg" , &len); +if (reg) + fdt_lmac = *reg; + +/* Check for a match */ +if (search_node == fdt_node && search_bgx == fdt_bgx && + search_lmac == fdt_lmac) +return node; + } + +return -1 ; +} + +/* +* get_mix_fdt_node: Search the device tree for the node corresponding to +* a given mix. +* +* fdt: Pointer to flat device tree +* search_node: Mix numa node to search for. +* search_index: Mix index to search for. +* +* returns: The device tree node of the lmac if found, +* or -1 otherwise. +*/ +static int get_mix_fdt_node (const void *fdt,int search_node,int search_index) +{ +int node; + +/* Iterate through all the mix fdt nodes */ + node =-1 ; +while ((node =fdt_node_offset_by_compatible ((void *)fdt, node, +"cavium,octeon-7890-mix" )) >=0 ) { +int parent; +int len; +const char *name; +int mix_numa_node; +const fdt32_t *reg; +int mix_index =-1 ; +u64 addr; + +/* Get the numa node of the mix from the parent node name */ + parent =fdt_parent_offset (fdt, node); +if (parent <0 || + ((name =fdt_get_name (fdt, parent, &len)) ==NULL ) || + ((name =strchr (name,'@' )) ==NULL )) +continue ; + + name++; + mix_numa_node =simple_strtol (name,NULL ,0 ) ?1 :0 ; + +/* Get the mix index from the reg property */ + reg =fdt_getprop (fdt, node,"reg" , &len); +if (reg) { + addr =fdt_translate_address ((void *)fdt, parent, reg); + mix_index = (addr >>11 ) &1 ; + } + +/* Check for a match */ +if (mix_numa_node == search_node && mix_index == search_index) +return node; + } + +return -1 ; +} + +/* +* fdt_fix_mix: Fix the mix nodes in the device tree. Only the mix nodes +* configured by the user will be preserved. All other mix +* nodes will be trimmed. +* +* fdt: Pointer to flat device tree +* +* returns: Zero on success, error otherwise. +*/ +static int fdt_fix_mix (const void *fdt) +{ +int node; +int next_node; +int len; +int i; + +/* Parse all the mix port environment variables */ +for (i =0 ; i <MAX_MIX_ENV_VARS ; i++) { +int env_node =0 ; +int env_bgx =-1 ; +int env_lmac =-1 ; +int lmac_fdt_node =-1 ; +int mix_fdt_node =-1 ; +int lmac_phandle; +char *compat; + +/* Get the lmac for this environment variable */ +if (parse_env_var (i, &env_bgx, &env_lmac)) +continue ; + +/* Get the fdt node for this lmac and add a phandle to it */ + compat ="cavium,octeon-7890-bgx-port" ; + lmac_fdt_node =get_lmac_fdt_node (fdt, env_node, env_bgx, + env_lmac, compat); +if (lmac_fdt_node <0 ) { +/* Must check for the xcv compatible string too */ + compat ="cavium,octeon-7360-xcv" ; + lmac_fdt_node =get_lmac_fdt_node (fdt, env_node, + env_bgx, env_lmac, + compat); +if (lmac_fdt_node <0 ) { +printf ("WARNING: Failed to get lmac fdt node for %d%d%d\n" , + env_node, env_bgx, env_lmac); +continue ; + } + } + + lmac_phandle =fdt_alloc_phandle ((void *)fdt); +fdt_set_phandle ((void *)fdt, lmac_fdt_node, lmac_phandle); + +/* Get the fdt mix node corresponding to this lmac */ + mix_fdt_node =get_mix_fdt_node (fdt, env_node, env_lmac); +if (mix_fdt_node <0 ) +continue ; + +/* Point the mix to the lmac */ +fdt_getprop (fdt, mix_fdt_node,"cavium,mac-handle" , &len); +fdt_setprop_inplace ((void *)fdt, mix_fdt_node, +"cavium,mac-handle" , &lmac_phandle, len); + } + +/* Trim unused mix'es from the device tree */ +for (node =fdt_next_node (fdt,-1 ,NULL ); node >=0 ; node = next_node) { +const char *compat; +const fdt32_t *reg; + + next_node =fdt_next_node (fdt, node,NULL ); + + compat =fdt_getprop (fdt, node,"compatible" , &len); +if (compat) { +if (strcmp (compat,"cavium,octeon-7890-mix" )) +continue ; + + reg =fdt_getprop (fdt, node,"cavium,mac-handle" , &len); +if (reg) { +if (*reg ==0xffff ) +fdt_nop_node ((void *)fdt, node); + } + } + } + +return 0 ; +} + +static void kill_fdt_phy (void *fdt,int offset,void *arg) +{ +int len, phy_offset; +const fdt32_t *php; +u32 phandle; + + php =fdt_getprop (fdt, offset,"phy-handle" , &len); +if (php && len ==sizeof (*php)) { + phandle =fdt32_to_cpu (*php); +fdt_nop_property (fdt, offset,"phy-handle" ); + phy_offset =fdt_node_offset_by_phandle (fdt, phandle); +if (phy_offset >0 ) +fdt_nop_node (fdt, phy_offset); + } +} + +void __fixup_xcv (void ) +{ +unsigned long bgx =env_get_ulong ("bgx_for_rgmii" ,10 , + (unsigned long )-1 ); +char fdt_key[16 ]; +int i; + +debug ("%s: BGX %d\n" , __func__, (int )bgx); + +for (i =0 ; i <3 ; i++) { +snprintf (fdt_key,sizeof (fdt_key), + bgx == i ?"%d,xcv" :"%d,not-xcv" , i); +debug ("%s: trimming bgx %lu with key %s\n" , + __func__, bgx, fdt_key); + +octeon_fdt_patch_rename ((void *)gd->fdt_blob, fdt_key, +"cavium,xcv-trim" , true,NULL ,NULL ); + } +} + +/* QLM0 - QLM6 */ +void __fixup_fdt (void ) +{ +int qlm; +int speed =0 ; + +for (qlm =0 ; qlm <7 ; qlm++) { +enum cvmx_qlm_mode mode; +char fdt_key[16 ]; +const char *type_str ="none" ; + + mode =cvmx_qlm_get_mode (qlm); +switch (mode) { +case CVMX_QLM_MODE_SGMII : +case CVMX_QLM_MODE_RGMII_SGMII : +case CVMX_QLM_MODE_RGMII_SGMII_1X1 : + type_str ="sgmii" ; +break ; +case CVMX_QLM_MODE_XAUI : +case CVMX_QLM_MODE_RGMII_XAUI : + speed = (cvmx_qlm_get_gbaud_mhz (qlm) *8 /10 ) *4 ; +if (speed ==10000 ) + type_str ="xaui" ; +else + type_str ="dxaui" ; +break ; +case CVMX_QLM_MODE_RXAUI : +case CVMX_QLM_MODE_RGMII_RXAUI : + type_str ="rxaui" ; +break ; +case CVMX_QLM_MODE_XLAUI : +case CVMX_QLM_MODE_RGMII_XLAUI : + type_str ="xlaui" ; +break ; +case CVMX_QLM_MODE_XFI : +case CVMX_QLM_MODE_RGMII_XFI : +case CVMX_QLM_MODE_RGMII_XFI_1X1 : + type_str ="xfi" ; +break ; +case CVMX_QLM_MODE_10G_KR : +case CVMX_QLM_MODE_RGMII_10G_KR : + type_str ="10G_KR" ; +break ; +case CVMX_QLM_MODE_40G_KR4 : +case CVMX_QLM_MODE_RGMII_40G_KR4 : + type_str ="40G_KR4" ; +break ; +case CVMX_QLM_MODE_SATA_2X1 : + type_str ="sata" ; +break ; +case CVMX_QLM_MODE_SGMII_2X1 : +case CVMX_QLM_MODE_XFI_1X2 : +case CVMX_QLM_MODE_10G_KR_1X2 : +case CVMX_QLM_MODE_RXAUI_1X2 : +case CVMX_QLM_MODE_MIXED :// special for DLM5 & DLM6 + { +cvmx_bgxx_cmrx_config_t cmr_config; +cvmx_bgxx_spux_br_pmd_control_t pmd_control; +int mux =cvmx_qlm_mux_interface (2 ); + +if (mux ==2 ) {// only dlm6 + cmr_config.u64 =csr_rd (CVMX_BGXX_CMRX_CONFIG (2 ,2 )); + pmd_control.u64 = +csr_rd (CVMX_BGXX_SPUX_BR_PMD_CONTROL (2 ,2 )); + }else { +if (qlm ==5 ) { + cmr_config.u64 = +csr_rd (CVMX_BGXX_CMRX_CONFIG (0 ,2 )); + pmd_control.u64 = +csr_rd (CVMX_BGXX_SPUX_BR_PMD_CONTROL (0 ,2 )); + }else { + cmr_config.u64 = +csr_rd (CVMX_BGXX_CMRX_CONFIG (2 ,2 )); + pmd_control.u64 = +csr_rd (CVMX_BGXX_SPUX_BR_PMD_CONTROL (2 ,2 )); + } + } +switch (cmr_config.s.lmac_type) { +case 0 : + type_str ="sgmii" ; +break ; +case 1 : + type_str ="xaui" ; +break ; +case 2 : + type_str ="rxaui" ; +break ; +case 3 : +if (pmd_control.s.train_en) + type_str ="10G_KR" ; +else + type_str ="xfi" ; +break ; +case 4 : +if (pmd_control.s.train_en) + type_str ="40G_KR4" ; +else + type_str ="xlaui" ; +break ; +default : + type_str ="none" ; +break ; + } +break ; + } +default : + type_str ="none" ; +break ; + } +sprintf (fdt_key,"%d,%s" , qlm, type_str); +debug ("Patching qlm %d for %s for mode %d%s\n" , qlm, fdt_key, mode, + no_phy[qlm] ?", removing PHY" :"" ); +octeon_fdt_patch_rename ((void *)gd->fdt_blob, fdt_key,NULL , true, + no_phy[qlm] ? kill_fdt_phy :NULL ,NULL ); + } +} + +int board_fix_fdt (void ) +{ +__fixup_fdt (); +__fixup_xcv (); + +/* Fix the mix ports */ +fdt_fix_mix (gd->fdt_blob); + +return 0 ; +} + +/* +* Here is the description of the parameters that are passed to QLM +* configuration: +* +* param0 : The QLM to configure +* param1 : Speed to configure the QLM at +* param2 : Mode the QLM to configure +* param3 : 1 = RC, 0 = EP +* param4 : 0 = GEN1, 1 = GEN2, 2 = GEN3 +* param5 : ref clock select, 0 = 100Mhz, 1 = 125MHz, 2 = 156MHz +* param6 : ref clock input to use: +* 0 - external reference (QLMx_REF_CLK) +* 1 = common clock 0 (QLMC_REF_CLK0) +* 2 = common_clock 1 (QLMC_REF_CLK1) +*/ +static void board_configure_qlms (void ) +{ +int speed[8 ] = {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +int mode[8 ] = {-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 ,-1 }; +int pcie_rc[8 ] = {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +int pcie_gen[8 ] = {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +int ref_clock_sel[8 ] = {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +int ref_clock_input[8 ] = {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +struct gpio_desc desc; +int rbgx, rqlm; +char env_var[16 ]; +int qlm; +int ret; + +/* RGMII PHY reset GPIO */ + ret =dm_gpio_lookup_name ("gpio-controllerA27" , &desc); +if (ret) +debug ("gpio ret=%d\n" , ret); + ret =dm_gpio_request (&desc,"rgmii_phy_reset" ); +if (ret) +debug ("gpio_request ret=%d\n" , ret); + ret =dm_gpio_set_dir_flags (&desc,GPIOD_IS_OUT ); +if (ret) +debug ("gpio dir ret=%d\n" , ret); + +/* Put RGMII PHY in reset */ +dm_gpio_set_value (&desc,0 ); + +octeon_init_qlm (0 ); + + rbgx =env_get_ulong ("bgx_for_rgmii" ,10 , (unsigned long )-1 ); +switch (rbgx) { +case 0 : + rqlm =2 ; +break ; +case 1 : + rqlm =3 ; +break ; +case 2 : + rqlm =5 ; +break ; +default : + rqlm =-1 ; +break ; + } + +for (qlm =0 ; qlm <7 ; qlm++) { +const char *mode_str; +char spd_env[16 ]; + + mode[qlm] =CVMX_QLM_MODE_DISABLED ; +sprintf (env_var,"qlm%d_mode" , qlm); + mode_str =env_get (env_var); +if (!mode_str) +continue ; + +if (qlm ==4 && mode[4 ] !=-1 && + mode[4 ] !=CVMX_QLM_MODE_SATA_2X1 ) { +printf ("Error: DLM 4 can only be configured for SATA\n" ); +continue ; + } + +if (strstr (mode_str,",no_phy" )) + no_phy[qlm] =1 ; + +if (!strncmp (mode_str,"sgmii" ,5 )) { +bool rgmii = false; + + speed[qlm] =1250 ; +if (rqlm == qlm && qlm <5 ) { + mode[qlm] =CVMX_QLM_MODE_RGMII_SGMII ; + rgmii = true; + }else if (qlm ==6 || qlm ==5 ) { +if (rqlm == qlm && qlm ==5 ) { + mode[qlm] =CVMX_QLM_MODE_RGMII_SGMII_1X1 ; + rgmii = true; + }else if (rqlm ==5 && qlm ==6 && + mode[5 ] !=CVMX_QLM_MODE_RGMII_SGMII_1X1 ) { + mode[qlm] =CVMX_QLM_MODE_RGMII_SGMII_2X1 ; + rgmii = true; + }else { + mode[qlm] =CVMX_QLM_MODE_SGMII_2X1 ; + } + }else { + mode[qlm] =CVMX_QLM_MODE_SGMII ; + } + ref_clock_sel[qlm] =2 ; + +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 + +if (no_phy[qlm]) { +int i; +int start =0 , stop =2 ; + + rbgx =0 ; +switch (qlm) { +case 3 : + rbgx =1 ; +case 2 : +for (i =0 ; i <4 ; i++) { +printf ("Ignoring PHY for interface: %d, port: %d\n" , + rbgx, i); +cvmx_helper_set_port_force_link_up (rbgx, i, true); + } +break ; +case 6 : + start =2 ; + stop =4 ; +case 5 : +for (i = start; i < stop; i++) { +printf ("Ignoring PHY for interface: %d, port: %d\n" , +2 , i); +cvmx_helper_set_port_force_link_up (2 , i, true); + } +break ; +default : +printf ("SGMII not supported for QLM/DLM %d\n" , + qlm); +break ; + } + } +printf ("QLM %d: SGMII%s\n" , + qlm, rgmii ?", RGMII" :"" ); + }else if (!strncmp (mode_str,"xaui" ,4 )) { + speed[qlm] =3125 ; + mode[qlm] =CVMX_QLM_MODE_XAUI ; + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +printf ("QLM %d: XAUI\n" , qlm); + }else if (!strncmp (mode_str,"dxaui" ,5 )) { + speed[qlm] =6250 ; + mode[qlm] =CVMX_QLM_MODE_XAUI ; + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +printf ("QLM %d: DXAUI\n" , qlm); + }else if (!strncmp (mode_str,"rxaui" ,5 )) { +bool rgmii = false; + + speed[qlm] =6250 ; +if (qlm ==5 || qlm ==6 ) { +if (rqlm == qlm && qlm ==5 ) { + mode[qlm] =CVMX_QLM_MODE_RGMII_RXAUI ; + rgmii = true; + }else { + mode[qlm] =CVMX_QLM_MODE_RXAUI_1X2 ; + } + }else { + mode[qlm] =CVMX_QLM_MODE_RXAUI ; + } + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +printf ("QLM %d: RXAUI%s\n" , + qlm, rgmii ?", rgmii" :"" ); + }else if (!strncmp (mode_str,"xlaui" ,5 )) { + speed[qlm] =103125 ; + mode[qlm] =CVMX_QLM_MODE_XLAUI ; + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +sprintf (spd_env,"qlm%d_speed" , qlm); +if (env_get (spd_env)) { +int spd =env_get_ulong (spd_env,0 ,8 ); + +if (spd) + speed[qlm] = spd; +else + speed[qlm] =103125 ; + } +printf ("QLM %d: XLAUI\n" , qlm); + }else if (!strncmp (mode_str,"xfi" ,3 )) { +bool rgmii = false; + + speed[qlm] =103125 ; +if (rqlm == qlm) { + mode[qlm] =CVMX_QLM_MODE_RGMII_XFI ; + rgmii = true; + }else if (qlm ==5 || qlm ==6 ) { + mode[qlm] =CVMX_QLM_MODE_XFI_1X2 ; + }else { + mode[qlm] =CVMX_QLM_MODE_XFI ; + } + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +printf ("QLM %d: XFI%s\n" , qlm, rgmii ?", RGMII" :"" ); + }else if (!strncmp (mode_str,"10G_KR" ,6 )) { + speed[qlm] =103125 ; +if (rqlm == qlm && qlm ==5 ) + mode[qlm] =CVMX_QLM_MODE_RGMII_10G_KR ; +else if (qlm ==5 || qlm ==6 ) + mode[qlm] =CVMX_QLM_MODE_10G_KR_1X2 ; +else + mode[qlm] =CVMX_QLM_MODE_10G_KR ; + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +printf ("QLM %d: 10G_KR\n" , qlm); + }else if (!strncmp (mode_str,"40G_KR4" ,7 )) { + speed[qlm] =103125 ; + mode[qlm] =CVMX_QLM_MODE_40G_KR4 ; + ref_clock_sel[qlm] =2 ; +if (qlm ==5 || qlm ==6 ) + ref_clock_input[qlm] =2 ;// use QLMC_REF_CLK1 +printf ("QLM %d: 40G_KR4\n" , qlm); + }else if (!strcmp (mode_str,"pcie" )) { +char *pmode; +int lanes =0 ; + +sprintf (env_var,"pcie%d_mode" , qlm); + pmode =env_get (env_var); +if (pmode && !strcmp (pmode,"ep" )) + pcie_rc[qlm] =0 ; +else + pcie_rc[qlm] =1 ; +sprintf (env_var,"pcie%d_gen" , qlm); + pcie_gen[qlm] =env_get_ulong (env_var,0 ,3 ); +sprintf (env_var,"pcie%d_lanes" , qlm); + lanes =env_get_ulong (env_var,0 ,8 ); +if (lanes ==8 ) { + mode[qlm] =CVMX_QLM_MODE_PCIE_1X8 ; + }else if (qlm ==5 || qlm ==6 ) { +if (lanes !=2 ) { +printf ("QLM%d: Invalid lanes selected, defaulting to 2 lanes\n" , + qlm); + } + mode[qlm] =CVMX_QLM_MODE_PCIE_1X2 ; + ref_clock_input[qlm] =1 ;// use QLMC_REF_CLK0 + }else { + mode[qlm] =CVMX_QLM_MODE_PCIE ; + } + ref_clock_sel[qlm] =0 ; +printf ("QLM %d: PCIe gen%d %s, x%d lanes\n" , + qlm, pcie_gen[qlm] +1 , + pcie_rc[qlm] ?"root complex" :"endpoint" , + lanes); + }else if (!strcmp (mode_str,"sata" )) { + mode[qlm] =CVMX_QLM_MODE_SATA_2X1 ; + ref_clock_sel[qlm] =0 ; + ref_clock_input[qlm] =1 ; +sprintf (spd_env,"qlm%d_speed" , qlm); +if (env_get (spd_env)) { +int spd =env_get_ulong (spd_env,0 ,8 ); + +if (spd ==1500 || spd ==3000 || spd ==3000 ) + speed[qlm] = spd; +else + speed[qlm] =6000 ; + }else { + speed[qlm] =6000 ; + } + }else { +printf ("QLM %d: disabled\n" , qlm); + } + } + +for (qlm =0 ; qlm <7 ; qlm++) { +int rc; + +if (mode[qlm] ==-1 ) +continue ; + +debug ("Configuring qlm%d with speed(%d), mode(%d), RC(%d), Gen(%d), REF_CLK(%d), CLK_SOURCE(%d)\n" , + qlm, speed[qlm], mode[qlm], pcie_rc[qlm], + pcie_gen[qlm] +1 , + ref_clock_sel[qlm], ref_clock_input[qlm]); + rc =octeon_configure_qlm (qlm, speed[qlm], mode[qlm], + pcie_rc[qlm], pcie_gen[qlm], + ref_clock_sel[qlm], + ref_clock_input[qlm]); + +if (speed[qlm] ==6250 ) { +if (mode[qlm] ==CVMX_QLM_MODE_RXAUI ) { +octeon_qlm_tune_v3 (0 , qlm, speed[qlm],0x12 , +0xa0 ,-1 ,-1 ); + }else { +octeon_qlm_tune_v3 (0 , qlm, speed[qlm],0xa , +0xa0 ,-1 ,-1 ); + } + }else if (speed[qlm] ==103125 ) { +octeon_qlm_tune_v3 (0 , qlm, speed[qlm],0xd ,0xd0 , +-1 ,-1 ); + } + +if (qlm ==4 && rc !=0 ) +/* +* There is a bug with SATA with 73xx. Until it's +* fixed we need to strip it from the device tree. +*/ +octeon_fdt_patch_rename ((void *)gd->fdt_blob,"4,none" , +NULL , true,NULL ,NULL ); + } + +dm_gpio_set_value (&desc,0 );/* Put RGMII PHY in reset */ +mdelay (10 ); +dm_gpio_set_value (&desc,1 );/* Take RGMII PHY out of reset */ +} + +int board_late_init (void ) +{ +board_configure_qlms (); + +return 0 ; +}
Signature · 1 line
2.29.2
PATCH 49/50 mips: octeon: Add Octeon PCIe host controller driver
In reply to Stefan RoeseThis patch adds the PCIe host controller driver for MIPS Octeon II/III. The driver mainly consist of the PCI config functions, as all of the complex serdes related port / lane setup, is done in the serdes / pcie code available in the "arch/mips/mach-octeon" directory.
---
drivers/pci/Kconfig | 6 ++ drivers/pci/Makefile | 1 + drivers/pci/pcie_octeon.c | 159 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 166 insertions(+) create mode 100644 drivers/pci/pcie_octeon.c
drivers/pci/Kconfig +6 -0
@@ -158,6 +158,12 @@ config PCI_OCTEONTX These controllers provide PCI configuration access to all on-board peripherals so it should only be disabled for testing purposes +config PCIE_OCTEON + bool "MIPS Octeon PCIe support" + depends on ARCH_OCTEON + help + Enable support for the MIPS Octeon SoC family PCIe controllers. + config PCI_XILINX bool "Xilinx AXI Bridge for PCI Express" depends on DM_PCI
drivers/pci/Makefile +1 -0
@@ -50,3 +50,4 @@ obj-$(CONFIG_PCIE_MEDIATEK) += pcie_mediatek.o obj-$(CONFIG_PCIE_ROCKCHIP) += pcie_rockchip.o obj-$(CONFIG_PCI_BRCMSTB) += pcie_brcmstb.o obj-$(CONFIG_PCI_OCTEONTX) += pci_octeontx.o +obj-$(CONFIG_PCIE_OCTEON) += pcie_octeon.o
drivers/pci/pcie_octeon.c new file +159 -0
159 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v2 49/50 mips: octeon: Add Octeon PCIe host controller driver
This patch adds the PCIe host controller driver for MIPS Octeon II/III. The driver mainly consist of the PCI config functions, as all of the complex serdes related port / lane setup, is done in the serdes / pcie code available in the "arch/mips/mach-octeon" directory.
---
I'm sending only this patch from the serdes / QLM series with the PCIe support, as it's the only one that has some changes. To not "pollute" the list with this huge series without need. Please let me know if I should post the complete series again to the list or provide a gitlab branch.
v2:
- Rebased on top of latest master
- Changed priv_auto_alloc_size to priv_auto
drivers/pci/Kconfig | 6 ++ drivers/pci/Makefile | 1 + drivers/pci/pcie_octeon.c | 159 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 166 insertions(+) create mode 100644 drivers/pci/pcie_octeon.c
drivers/pci/Kconfig +6 -0
@@ -158,6 +158,12 @@ config PCI_OCTEONTX These controllers provide PCI configuration access to all on-board peripherals so it should only be disabled for testing purposes +config PCIE_OCTEON + bool "MIPS Octeon PCIe support" + depends on ARCH_OCTEON + help + Enable support for the MIPS Octeon SoC family PCIe controllers. + config PCI_XILINX bool "Xilinx AXI Bridge for PCI Express" depends on DM_PCI
drivers/pci/Makefile +1 -0
@@ -51,3 +51,4 @@ obj-$(CONFIG_PCIE_ROCKCHIP) += pcie_rockchip.o obj-$(CONFIG_PCIE_DW_ROCKCHIP) += pcie_dw_rockchip.o obj-$(CONFIG_PCI_BRCMSTB) += pcie_brcmstb.o obj-$(CONFIG_PCI_OCTEONTX) += pci_octeontx.o +obj-$(CONFIG_PCIE_OCTEON) += pcie_octeon.o
drivers/pci/pcie_octeon.c new file +159 -0
159 lines not on this page · raw message
Signature · 1 line
2.31.1
PATCH 50/50 mips: octeon: octeon_ebb7304_defconfig: Enable Octeon PCIe and E1000
In reply to Stefan RoeseThis patch changes the MIPS Octeon defconfig to enable some features for PCIe enablement. This includes CONFIG_BOARD_LATE_INIT to call the board specific serdes init code.
With these features enabled, the serdes and PCIe driver including the Intel E1000 driver can be tested on the Octeon EBB7304.
---
configs/octeon_ebb7304_defconfig | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
configs/octeon_ebb7304_defconfig +4 -1
@@ -10,7 +10,9 @@ CONFIG_ARCH_OCTEON=y # CONFIG_MIPS_CACHE_SETUP is not set # CONFIG_MIPS_CACHE_DISABLE is not set CONFIG_DEBUG_UART=y +CONFIG_OF_BOARD_FIXUP=y CONFIG_SYS_CONSOLE_INFO_QUIET=y +CONFIG_BOARD_LATE_INIT=y CONFIG_HUSH_PARSER=y CONFIG_CMD_GPIO=y CONFIG_CMD_I2C=y
@@ -42,9 +44,10 @@ CONFIG_DM_SPI_FLASH=y CONFIG_SPI_FLASH_ATMEL=y CONFIG_SPI_FLASH_SPANSION=y CONFIG_SPI_FLASH_STMICRO=y -# CONFIG_NETDEVICES is not set +CONFIG_E1000=y CONFIG_PCI=y CONFIG_DM_PCI=y +CONFIG_PCIE_OCTEON=y CONFIG_RAM=y CONFIG_RAM_OCTEON=y CONFIG_RAM_OCTEON_DDR4=y
Signature · 1 line
2.29.2
PATCH v2 33/50 mips: octeon: Add misc remaining header files
In reply to Stefan RoeseFrom: Aaron Williams <[email protected]>
Import misc remaining header files from 2013 U-Boot. These will be used by the later added drivers to support PCIe and networking on the MIPS Octeon II / III platforms.
---
v2:
- Add missing mach/octeon_qlm.h file (forgot to commit it in v1)
.../mach-octeon/include/mach/cvmx-address.h | 209 ++ .../mach-octeon/include/mach/cvmx-cmd-queue.h | 441 +++ .../mach-octeon/include/mach/cvmx-csr-enums.h | 87 + arch/mips/mach-octeon/include/mach/cvmx-csr.h | 78 + .../mach-octeon/include/mach/cvmx-error.h | 456 +++ arch/mips/mach-octeon/include/mach/cvmx-fpa.h | 217 ++ .../mips/mach-octeon/include/mach/cvmx-fpa1.h | 196 ++ .../mips/mach-octeon/include/mach/cvmx-fpa3.h | 566 ++++ .../include/mach/cvmx-global-resources.h | 213 ++ arch/mips/mach-octeon/include/mach/cvmx-gmx.h | 16 + .../mach-octeon/include/mach/cvmx-hwfau.h | 606 ++++ .../mach-octeon/include/mach/cvmx-hwpko.h | 570 ++++ arch/mips/mach-octeon/include/mach/cvmx-ilk.h | 154 + arch/mips/mach-octeon/include/mach/cvmx-ipd.h | 233 ++ .../mach-octeon/include/mach/cvmx-packet.h | 40 + .../mips/mach-octeon/include/mach/cvmx-pcie.h | 279 ++ arch/mips/mach-octeon/include/mach/cvmx-pip.h | 1080 ++++++ .../include/mach/cvmx-pki-resources.h | 157 + arch/mips/mach-octeon/include/mach/cvmx-pki.h | 970 ++++++ .../mach/cvmx-pko-internal-ports-range.h | 43 + .../include/mach/cvmx-pko3-queue.h | 175 + arch/mips/mach-octeon/include/mach/cvmx-pow.h | 2991 +++++++++++++++++ arch/mips/mach-octeon/include/mach/cvmx-qlm.h | 304 ++ .../mach-octeon/include/mach/cvmx-scratch.h | 113 + arch/mips/mach-octeon/include/mach/cvmx-wqe.h | 1462 ++++++++ .../mach-octeon/include/mach/octeon_qlm.h | 109 + 26 files changed, 11765 insertions(+) create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-address.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-cmd-queue.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-csr-enums.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-csr.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-error.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-fpa.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-fpa1.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-fpa3.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-global-resources.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-gmx.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-hwfau.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-hwpko.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-ilk.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-ipd.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-packet.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pcie.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pip.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pki-resources.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pki.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pko-internal-ports-range.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pko3-queue.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-pow.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-qlm.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-scratch.h create mode 100644 arch/mips/mach-octeon/include/mach/cvmx-wqe.h create mode 100644 arch/mips/mach-octeon/include/mach/octeon_qlm.h
arch/mips/mach-octeon/include/mach/cvmx-address.h new file +209 -0
@@ -0,0 +1,209 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Marvell International Ltd. +* +* Typedefs and defines for working with Octeon physical addresses. +*/ + +#ifndef __CVMX_ADDRESS_H__ +#define __CVMX_ADDRESS_H__ + +typedef enum { +CVMX_MIPS_SPACE_XKSEG =3LL , +CVMX_MIPS_SPACE_XKPHYS =2LL , +CVMX_MIPS_SPACE_XSSEG =1LL , +CVMX_MIPS_SPACE_XUSEG =0LL +}cvmx_mips_space_t ; + +typedef enum { +CVMX_MIPS_XKSEG_SPACE_KSEG0 =0LL , +CVMX_MIPS_XKSEG_SPACE_KSEG1 =1LL , +CVMX_MIPS_XKSEG_SPACE_SSEG =2LL , +CVMX_MIPS_XKSEG_SPACE_KSEG3 =3LL +}cvmx_mips_xkseg_space_t ; + +/* decodes <14:13> of a kseg3 window address */ +typedef enum { +CVMX_ADD_WIN_SCR =0L , +CVMX_ADD_WIN_DMA =1L , +CVMX_ADD_WIN_UNUSED =2L , +CVMX_ADD_WIN_UNUSED2 =3L +}cvmx_add_win_dec_t ; + +/* decode within DMA space */ +typedef enum { +CVMX_ADD_WIN_DMA_ADD =0L , +CVMX_ADD_WIN_DMA_SENDMEM =1L , +/* store data must be normal DRAM memory space address in this case */ +CVMX_ADD_WIN_DMA_SENDDMA =2L , +/* see CVMX_ADD_WIN_DMA_SEND_DEC for data contents */ +CVMX_ADD_WIN_DMA_SENDIO =3L , +/* store data must be normal IO space address in this case */ +CVMX_ADD_WIN_DMA_SENDSINGLE =4L , +/* no write buffer data needed/used */ +}cvmx_add_win_dma_dec_t ; + +/** +* Physical Address Decode +* +* Octeon-I HW never interprets this X (<39:36> reserved +* for future expansion), software should set to 0. +* +* - 0x0 XXX0 0000 0000 to DRAM Cached +* - 0x0 XXX0 0FFF FFFF +* +* - 0x0 XXX0 1000 0000 to Boot Bus Uncached (Converted to 0x1 00X0 1000 0000 +* - 0x0 XXX0 1FFF FFFF + EJTAG to 0x1 00X0 1FFF FFFF) +* +* - 0x0 XXX0 2000 0000 to DRAM Cached +* - 0x0 XXXF FFFF FFFF +* +* - 0x1 00X0 0000 0000 to Boot Bus Uncached +* - 0x1 00XF FFFF FFFF +* +* - 0x1 01X0 0000 0000 to Other NCB Uncached +* - 0x1 FFXF FFFF FFFF devices +* +* Decode of all Octeon addresses +*/ +typedef union { +u64 u64; +struct { +cvmx_mips_space_t R :2 ; +u64 offset :62 ; + } sva; + +struct { +u64 zeroes :33 ; +u64 offset :31 ; + } suseg; + +struct { +u64 ones :33 ; +cvmx_mips_xkseg_space_t sp :2 ; +u64 offset :29 ; + } sxkseg; + +struct { +cvmx_mips_space_t R :2 ; +u64 cca :3 ; +u64 mbz :10 ; +u64 pa :49 ; + } sxkphys; + +struct { +u64 mbz :15 ; +u64 is_io :1 ; +u64 did :8 ; +u64 unaddr :4 ; +u64 offset :36 ; + } sphys; + +struct { +u64 zeroes :24 ; +u64 unaddr :4 ; +u64 offset :36 ; + } smem; + +struct { +u64 mem_region :2 ; +u64 mbz :13 ; +u64 is_io :1 ; +u64 did :8 ; +u64 unaddr :4 ; +u64 offset :36 ; + } sio; + +struct { +u64 ones :49 ; +cvmx_add_win_dec_t csrdec :2 ; +u64 addr :13 ; + } sscr; + +/* there should only be stores to IOBDMA space, no loads */ +struct { +u64 ones :49 ; +cvmx_add_win_dec_t csrdec :2 ; +u64 unused2 :3 ; +cvmx_add_win_dma_dec_t type :3 ; +u64 addr :7 ; + } sdma; + +struct { +u64 didspace :24 ; +u64 unused :40 ; + } sfilldidspace; +}cvmx_addr_t ; + +/* These macros for used by 32 bit applications */ + +#define CVMX_MIPS32_SPACE_KSEG0 1l +#define CVMX_ADD_SEG32 (segment, add) (((s32)segment << 31) | (s32)(add)) + +/* +* Currently all IOs are performed using XKPHYS addressing. Linux uses the +* CvmMemCtl register to enable XKPHYS addressing to IO space from user mode. +* Future OSes may need to change the upper bits of IO addresses. The +* following define controls the upper two bits for all IO addresses generated +* by the simple executive library +*/ +#define CVMX_IO_SEG CVMX_MIPS_SPACE_XKPHYS + +/* These macros simplify the process of creating common IO addresses */ +#define CVMX_ADD_SEG (segment, add) ((((u64)segment) << 62) | (add)) + +#define CVMX_ADD_IO_SEG (add) (add) + +#define CVMX_ADDR_DIDSPACE (did) (((CVMX_IO_SEG) << 22) | ((1ULL) << 8) | (did)) +#define CVMX_ADDR_DID (did) (CVMX_ADDR_DIDSPACE(did) << 40) +#define CVMX_FULL_DID (did, subdid) (((did) << 3) | (subdid)) + +/* from include/ncb_rsl_id.v */ +#define CVMX_OCT_DID_MIS 0ULL/* misc stuff */ +#define CVMX_OCT_DID_GMX0 1ULL +#define CVMX_OCT_DID_GMX1 2ULL +#define CVMX_OCT_DID_PCI 3ULL +#define CVMX_OCT_DID_KEY 4ULL +#define CVMX_OCT_DID_FPA 5ULL +#define CVMX_OCT_DID_DFA 6ULL +#define CVMX_OCT_DID_ZIP 7ULL +#define CVMX_OCT_DID_RNG 8ULL +#define CVMX_OCT_DID_IPD 9ULL +#define CVMX_OCT_DID_PKT 10ULL +#define CVMX_OCT_DID_TIM 11ULL +#define CVMX_OCT_DID_TAG 12ULL +/* the rest are not on the IO bus */ +#define CVMX_OCT_DID_L2C 16ULL +#define CVMX_OCT_DID_LMC 17ULL +#define CVMX_OCT_DID_SPX0 18ULL +#define CVMX_OCT_DID_SPX1 19ULL +#define CVMX_OCT_DID_PIP 20ULL +#define CVMX_OCT_DID_ASX0 22ULL +#define CVMX_OCT_DID_ASX1 23ULL +#define CVMX_OCT_DID_IOB 30ULL + +#define CVMX_OCT_DID_PKT_SEND CVMX_FULL_DID(CVMX_OCT_DID_PKT, 2ULL) +#define CVMX_OCT_DID_TAG_SWTAG CVMX_FULL_DID(CVMX_OCT_DID_TAG, 0ULL) +#define CVMX_OCT_DID_TAG_TAG1 CVMX_FULL_DID(CVMX_OCT_DID_TAG, 1ULL) +#define CVMX_OCT_DID_TAG_TAG2 CVMX_FULL_DID(CVMX_OCT_DID_TAG, 2ULL) +#define CVMX_OCT_DID_TAG_TAG3 CVMX_FULL_DID(CVMX_OCT_DID_TAG, 3ULL) +#define CVMX_OCT_DID_TAG_NULL_RD CVMX_FULL_DID(CVMX_OCT_DID_TAG, 4ULL) +#define CVMX_OCT_DID_TAG_TAG5 CVMX_FULL_DID(CVMX_OCT_DID_TAG, 5ULL) +#define CVMX_OCT_DID_TAG_CSR CVMX_FULL_DID(CVMX_OCT_DID_TAG, 7ULL) +#define CVMX_OCT_DID_FAU_FAI CVMX_FULL_DID(CVMX_OCT_DID_IOB, 0ULL) +#define CVMX_OCT_DID_TIM_CSR CVMX_FULL_DID(CVMX_OCT_DID_TIM, 0ULL) +#define CVMX_OCT_DID_KEY_RW CVMX_FULL_DID(CVMX_OCT_DID_KEY, 0ULL) +#define CVMX_OCT_DID_PCI_6 CVMX_FULL_DID(CVMX_OCT_DID_PCI, 6ULL) +#define CVMX_OCT_DID_MIS_BOO CVMX_FULL_DID(CVMX_OCT_DID_MIS, 0ULL) +#define CVMX_OCT_DID_PCI_RML CVMX_FULL_DID(CVMX_OCT_DID_PCI, 0ULL) +#define CVMX_OCT_DID_IPD_CSR CVMX_FULL_DID(CVMX_OCT_DID_IPD, 7ULL) +#define CVMX_OCT_DID_DFA_CSR CVMX_FULL_DID(CVMX_OCT_DID_DFA, 7ULL) +#define CVMX_OCT_DID_MIS_CSR CVMX_FULL_DID(CVMX_OCT_DID_MIS, 7ULL) +#define CVMX_OCT_DID_ZIP_CSR CVMX_FULL_DID(CVMX_OCT_DID_ZIP, 0ULL) + +/* Cast to unsigned long long, mainly for use in printfs. */ +#define CAST_ULL (v) ((unsigned long long)(v)) + +#define UNMAPPED_PTR (x) ((1ULL << 63) | (x)) + +#endif /* __CVMX_ADDRESS_H__ */
arch/mips/mach-octeon/include/mach/cvmx-cmd-queue.h new file +441 -0
441 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-csr-enums.h new file +87 -0
87 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-csr.h new file +78 -0
78 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-error.h new file +456 -0
456 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-fpa.h new file +217 -0
217 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-fpa1.h new file +196 -0
196 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-fpa3.h new file +566 -0
566 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-global-resources.h new file +213 -0
213 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-gmx.h new file +16 -0
@@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Marvell International Ltd. +* +* Interface to the GMX hardware. +*/ + +#ifndef __CVMX_GMX_H__ +#define __CVMX_GMX_H__ + +/* CSR typedefs have been moved to cvmx-gmx-defs.h */ + +int cvmx_gmx_set_backpressure_override (u32 interface,u32 port_mask); +int cvmx_agl_set_backpressure_override (u32 interface,u32 port_mask); + +#endif
arch/mips/mach-octeon/include/mach/cvmx-hwfau.h new file +606 -0
521 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-hwpko.h new file +570 -0
570 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-ilk.h new file +154 -0
154 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-ipd.h new file +233 -0
233 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-packet.h new file +40 -0
Lines of this file are not shown. View the raw message.
arch/mips/mach-octeon/include/mach/cvmx-pcie.h new file +279 -0
279 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-pip.h new file +1080 -0
1,080 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-pki-resources.h new file +157 -0
157 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-pki.h new file +970 -0
970 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-pko-internal-ports-range.h new file +43 -0
43 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-pko3-queue.h new file +175 -0
175 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-pow.h new file +2991 -0
2,991 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-qlm.h new file +304 -0
304 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-scratch.h new file +113 -0
113 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/cvmx-wqe.h new file +1462 -0
1,462 lines not on this page · raw message
arch/mips/mach-octeon/include/mach/octeon_qlm.h new file +109 -0
109 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.31.1
Part of the diff is not shown here. View the raw message.
PATCH v2 33/50 mips: octeon: Add misc remaining header files
This message is left out to keep this page within its size limit. Read the full message.