drivers/phy/marvell/comphy_cp110.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015-2016 Marvell International Ltd.
   4  */
   5
   6 #include <common.h>
   7 #include <fdtdec.h>
   8 #include <log.h>
   9 #include <asm/io.h>
  10 #include <asm/arch/cpu.h>
  11 #include <asm/arch/soc.h>
  12
  13 #include "comphy_core.h"
  14 #include "comphy_hpipe.h"
  15 #include "sata.h"
  16 #include "utmi_phy.h"
  17
  18 DECLARE_GLOBAL_DATA_PTR;
  19
  20 #define SD_ADDR(base, lane)                     (base + 0x1000 * lane)
  21 #define HPIPE_ADDR(base, lane)                  (SD_ADDR(base, lane) + 0x800)
  22 #define COMPHY_ADDR(base, lane)                 (base + 0x28 * lane)
  23
  24 struct utmi_phy_data {
  25         void __iomem *utmi_base_addr;
  26         void __iomem *usb_cfg_addr;
  27         void __iomem *utmi_cfg_addr;
  28         u32 utmi_phy_port;
  29 };
  30
  31 /*
  32  * For CP-110 we have 2 Selector registers "PHY Selectors",
  33  * and "PIPE Selectors".
  34  * PIPE selector include USB and PCIe options.
  35  * PHY selector include the Ethernet and SATA options, every Ethernet
  36  * option has different options, for example: serdes lane2 had option
  37  * Eth_port_0 that include (SGMII0, RXAUI0, SFI)
  38  */
  39 struct comphy_mux_data cp110_comphy_phy_mux_data[] = {
  40         {4, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_SGMII1, 0x1}, /* Lane 0 */
  41              {PHY_TYPE_SATA1, 0x4} } },
  42         {4, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_SGMII2, 0x1}, /* Lane 1 */
  43              {PHY_TYPE_SATA0, 0x4} } },
  44         {6, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_SGMII0, 0x1}, /* Lane 2 */
  45              {PHY_TYPE_RXAUI0, 0x1}, {PHY_TYPE_SFI, 0x1},
  46              {PHY_TYPE_SATA0, 0x4} } },
  47         {8, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_RXAUI1, 0x1}, /* Lane 3 */
  48              {PHY_TYPE_SGMII1, 0x2}, {PHY_TYPE_SATA1, 0x4} } },
  49         {7, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_SGMII0, 0x2}, /* Lane 4 */
  50              {PHY_TYPE_RXAUI0, 0x2}, {PHY_TYPE_SFI, 0x2},
  51              {PHY_TYPE_SGMII1, 0x1} } },
  52         {6, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_SGMII2, 0x1}, /* Lane 5 */
  53              {PHY_TYPE_RXAUI1, 0x2}, {PHY_TYPE_SATA1, 0x4} } },
  54 };
  55
  56 struct comphy_mux_data cp110_comphy_pipe_mux_data[] = {
  57         {2, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_PEX0, 0x4} } }, /* Lane 0 */
  58         {4, {{PHY_TYPE_UNCONNECTED, 0x0}, /* Lane 1 */
  59              {PHY_TYPE_USB3_HOST0, 0x1}, {PHY_TYPE_USB3_DEVICE, 0x2},
  60              {PHY_TYPE_PEX0, 0x4} } },
  61         {3, {{PHY_TYPE_UNCONNECTED, 0x0}, /* Lane 2 */
  62              {PHY_TYPE_USB3_HOST0, 0x1}, {PHY_TYPE_PEX0, 0x4} } },
  63         {3, {{PHY_TYPE_UNCONNECTED, 0x0}, /* Lane 3 */
  64              {PHY_TYPE_USB3_HOST1, 0x1}, {PHY_TYPE_PEX0, 0x4} } },
  65         {4, {{PHY_TYPE_UNCONNECTED, 0x0}, /* Lane 4 */
  66              {PHY_TYPE_USB3_HOST1, 0x1},
  67              {PHY_TYPE_USB3_DEVICE, 0x2}, {PHY_TYPE_PEX1, 0x4} } },
  68         {2, {{PHY_TYPE_UNCONNECTED, 0x0}, {PHY_TYPE_PEX2, 0x4} } }, /* Lane 5 */
  69 };
  70
  71 static u32 polling_with_timeout(void __iomem *addr, u32 val,
  72                                 u32 mask, unsigned long usec_timout)
  73 {
  74         u32 data;
  75
  76         do {
  77                 udelay(1);
  78                 data = readl(addr) & mask;
  79         } while (data != val  && --usec_timout > 0);
  80
  81         if (usec_timout == 0)
  82                 return data;
  83
  84         return 0;
  85 }
  86
  87 static int comphy_pcie_power_up(u32 lane, u32 pcie_width, bool clk_src,
  88                                 bool is_end_point, void __iomem *hpipe_base,
  89                                 void __iomem *comphy_base)
  90 {
  91         u32 mask, data, ret = 1;
  92         void __iomem *hpipe_addr = HPIPE_ADDR(hpipe_base, lane);
  93         void __iomem *comphy_addr = COMPHY_ADDR(comphy_base, lane);
  94         void __iomem *addr;
  95         u32 pcie_clk = 0; /* set input by default */
  96
  97         debug_enter();
  98
  99         /*
 100          * ToDo:
 101          * Add SAR (Sample-At-Reset) configuration for the PCIe clock
 102          * direction. SAR code is currently not ported from Marvell
 103          * U-Boot to mainline version.
 104          *
 105          * SerDes Lane 4/5 got the PCIe ref-clock #1,
 106          * and SerDes Lane 0 got PCIe ref-clock #0
 107          */
 108         debug("PCIe clock = %x\n", pcie_clk);
 109         debug("PCIe RC    = %d\n", !is_end_point);
 110         debug("PCIe width = %d\n", pcie_width);
 111
 112         /* enable PCIe by4 and by2 */
 113         if (lane == 0) {
 114                 if (pcie_width == 4) {
 115                         reg_set(comphy_base + COMMON_PHY_SD_CTRL1,
 116                                 0x1 << COMMON_PHY_SD_CTRL1_PCIE_X4_EN_OFFSET,
 117                                 COMMON_PHY_SD_CTRL1_PCIE_X4_EN_MASK);
 118                 } else if (pcie_width == 2) {
 119                         reg_set(comphy_base + COMMON_PHY_SD_CTRL1,
 120                                 0x1 << COMMON_PHY_SD_CTRL1_PCIE_X2_EN_OFFSET,
 121                                 COMMON_PHY_SD_CTRL1_PCIE_X2_EN_MASK);
 122                 }
 123         }
 124
 125         /*
 126          * If PCIe clock is output and clock source from SerDes lane 5,
 127          * we need to configure the clock-source MUX.
 128          * By default, the clock source is from lane 4
 129          */
 130         if (pcie_clk && clk_src && (lane == 5)) {
 131                 reg_set((void __iomem *)DFX_DEV_GEN_CTRL12,
 132                         0x3 << DFX_DEV_GEN_PCIE_CLK_SRC_OFFSET,
 133                         DFX_DEV_GEN_PCIE_CLK_SRC_MASK);
 134         }
 135
 136         debug("stage: RFU configurations - hard reset comphy\n");
 137         /* RFU configurations - hard reset comphy */
 138         mask = COMMON_PHY_CFG1_PWR_UP_MASK;
 139         data = 0x1 << COMMON_PHY_CFG1_PWR_UP_OFFSET;
 140         mask |= COMMON_PHY_CFG1_PIPE_SELECT_MASK;
 141         data |= 0x1 << COMMON_PHY_CFG1_PIPE_SELECT_OFFSET;
 142         mask |= COMMON_PHY_CFG1_PWR_ON_RESET_MASK;
 143         data |= 0x0 << COMMON_PHY_CFG1_PWR_ON_RESET_OFFSET;
 144         mask |= COMMON_PHY_CFG1_CORE_RSTN_MASK;
 145         data |= 0x0 << COMMON_PHY_CFG1_CORE_RSTN_OFFSET;
 146         mask |= COMMON_PHY_PHY_MODE_MASK;
 147         data |= 0x0 << COMMON_PHY_PHY_MODE_OFFSET;
 148         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
 149
 150         /* release from hard reset */
 151         mask = COMMON_PHY_CFG1_PWR_ON_RESET_MASK;
 152         data = 0x1 << COMMON_PHY_CFG1_PWR_ON_RESET_OFFSET;
 153         mask |= COMMON_PHY_CFG1_CORE_RSTN_MASK;
 154         data |= 0x1 << COMMON_PHY_CFG1_CORE_RSTN_OFFSET;
 155         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
 156
 157         /* Wait 1ms - until band gap and ref clock ready */
 158         mdelay(1);
 159         /* Start comphy Configuration */
 160         debug("stage: Comphy configuration\n");
 161         /* Set PIPE soft reset */
 162         mask = HPIPE_RST_CLK_CTRL_PIPE_RST_MASK;
 163         data = 0x1 << HPIPE_RST_CLK_CTRL_PIPE_RST_OFFSET;
 164         /* Set PHY datapath width mode for V0 */
 165         mask |= HPIPE_RST_CLK_CTRL_FIXED_PCLK_MASK;
 166         data |= 0x1 << HPIPE_RST_CLK_CTRL_FIXED_PCLK_OFFSET;
 167         /* Set Data bus width USB mode for V0 */
 168         mask |= HPIPE_RST_CLK_CTRL_PIPE_WIDTH_MASK;
 169         data |= 0x0 << HPIPE_RST_CLK_CTRL_PIPE_WIDTH_OFFSET;
 170         /* Set CORE_CLK output frequency for 250Mhz */
 171         mask |= HPIPE_RST_CLK_CTRL_CORE_FREQ_SEL_MASK;
 172         data |= 0x0 << HPIPE_RST_CLK_CTRL_CORE_FREQ_SEL_OFFSET;
 173         reg_set(hpipe_addr + HPIPE_RST_CLK_CTRL_REG, data, mask);
 174         /* Set PLL ready delay for 0x2 */
 175         data = 0x2 << HPIPE_CLK_SRC_LO_PLL_RDY_DL_OFFSET;
 176         mask = HPIPE_CLK_SRC_LO_PLL_RDY_DL_MASK;
 177         if (pcie_width != 1) {
 178                 data |= 0x1 << HPIPE_CLK_SRC_LO_BUNDLE_PERIOD_SEL_OFFSET;
 179                 mask |= HPIPE_CLK_SRC_LO_BUNDLE_PERIOD_SEL_MASK;
 180                 data |= 0x1 << HPIPE_CLK_SRC_LO_BUNDLE_PERIOD_SCALE_OFFSET;
 181                 mask |= HPIPE_CLK_SRC_LO_BUNDLE_PERIOD_SCALE_MASK;
 182         }
 183         reg_set(hpipe_addr + HPIPE_CLK_SRC_LO_REG, data, mask);
 184
 185         /* Set PIPE mode interface to PCIe3 - 0x1  & set lane order */
 186         data = 0x1 << HPIPE_CLK_SRC_HI_MODE_PIPE_OFFSET;
 187         mask = HPIPE_CLK_SRC_HI_MODE_PIPE_MASK;
 188         if (pcie_width != 1) {
 189                 mask |= HPIPE_CLK_SRC_HI_LANE_STRT_MASK;
 190                 mask |= HPIPE_CLK_SRC_HI_LANE_MASTER_MASK;
 191                 mask |= HPIPE_CLK_SRC_HI_LANE_BREAK_MASK;
 192                 if (lane == 0) {
 193                         data |= 0x1 << HPIPE_CLK_SRC_HI_LANE_STRT_OFFSET;
 194                         data |= 0x1 << HPIPE_CLK_SRC_HI_LANE_MASTER_OFFSET;
 195                 } else if (lane == (pcie_width - 1)) {
 196                         data |= 0x1 << HPIPE_CLK_SRC_HI_LANE_BREAK_OFFSET;
 197                 }
 198         }
 199         reg_set(hpipe_addr + HPIPE_CLK_SRC_HI_REG, data, mask);
 200         /* Config update polarity equalization */
 201         reg_set(hpipe_addr + HPIPE_LANE_EQ_CFG1_REG,
 202                 0x1 << HPIPE_CFG_UPDATE_POLARITY_OFFSET,
 203                 HPIPE_CFG_UPDATE_POLARITY_MASK);
 204         /* Set PIPE version 4 to mode enable */
 205         reg_set(hpipe_addr + HPIPE_DFE_CTRL_28_REG,
 206                 0x1 << HPIPE_DFE_CTRL_28_PIPE4_OFFSET,
 207                 HPIPE_DFE_CTRL_28_PIPE4_MASK);
 208         /* TODO: check if pcie clock is output/input - for bringup use input*/
 209         /* Enable PIN clock 100M_125M */
 210         mask = 0;
 211         data = 0;
 212         /* Only if clock is output, configure the clock-source mux */
 213         if (pcie_clk) {
 214                 mask |= HPIPE_MISC_CLK100M_125M_MASK;
 215                 data |= 0x1 << HPIPE_MISC_CLK100M_125M_OFFSET;
 216         }
 217         /*
 218          * Set PIN_TXDCLK_2X Clock Frequency Selection for outputs 500MHz
 219          * clock
 220          */
 221         mask |= HPIPE_MISC_TXDCLK_2X_MASK;
 222         data |= 0x0 << HPIPE_MISC_TXDCLK_2X_OFFSET;
 223         /* Enable 500MHz Clock */
 224         mask |= HPIPE_MISC_CLK500_EN_MASK;
 225         data |= 0x1 << HPIPE_MISC_CLK500_EN_OFFSET;
 226         if (pcie_clk) { /* output */
 227                 /* Set reference clock comes from group 1 */
 228                 mask |= HPIPE_MISC_REFCLK_SEL_MASK;
 229                 data |= 0x0 << HPIPE_MISC_REFCLK_SEL_OFFSET;
 230         } else {
 231                 /* Set reference clock comes from group 2 */
 232                 mask |= HPIPE_MISC_REFCLK_SEL_MASK;
 233                 data |= 0x1 << HPIPE_MISC_REFCLK_SEL_OFFSET;
 234         }
 235         mask |= HPIPE_MISC_ICP_FORCE_MASK;
 236         data |= 0x1 << HPIPE_MISC_ICP_FORCE_OFFSET;
 237         reg_set(hpipe_addr + HPIPE_MISC_REG, data, mask);
 238         if (pcie_clk) { /* output */
 239                 /* Set reference frequcency select - 0x2 for 25MHz*/
 240                 mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
 241                 data = 0x2 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
 242         } else {
 243                 /* Set reference frequcency select - 0x0 for 100MHz*/
 244                 mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
 245                 data = 0x0 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
 246         }
 247         /* Set PHY mode to PCIe */
 248         mask |= HPIPE_PWR_PLL_PHY_MODE_MASK;
 249         data |= 0x3 << HPIPE_PWR_PLL_PHY_MODE_OFFSET;
 250         reg_set(hpipe_addr + HPIPE_PWR_PLL_REG, data, mask);
 251
 252         /* ref clock alignment */
 253         if (pcie_width != 1) {
 254                 mask = HPIPE_LANE_ALIGN_OFF_MASK;
 255                 data = 0x0 << HPIPE_LANE_ALIGN_OFF_OFFSET;
 256                 reg_set(hpipe_addr + HPIPE_LANE_ALIGN_REG, data, mask);
 257         }
 258
 259         /*
 260          * Set the amount of time spent in the LoZ state - set for 0x7 only if
 261          * the PCIe clock is output
 262          */
 263         if (pcie_clk) {
 264                 reg_set(hpipe_addr + HPIPE_GLOBAL_PM_CTRL,
 265                         0x7 << HPIPE_GLOBAL_PM_RXDLOZ_WAIT_OFFSET,
 266                         HPIPE_GLOBAL_PM_RXDLOZ_WAIT_MASK);
 267         }
 268
 269         /* Set Maximal PHY Generation Setting(8Gbps) */
 270         mask = HPIPE_INTERFACE_GEN_MAX_MASK;
 271         data = 0x2 << HPIPE_INTERFACE_GEN_MAX_OFFSET;
 272         /* Bypass frame detection and sync detection for RX DATA */
 273         mask = HPIPE_INTERFACE_DET_BYPASS_MASK;
 274         data = 0x1 << HPIPE_INTERFACE_DET_BYPASS_OFFSET;
 275         /* Set Link Train Mode (Tx training control pins are used) */
 276         mask |= HPIPE_INTERFACE_LINK_TRAIN_MASK;
 277         data |= 0x1 << HPIPE_INTERFACE_LINK_TRAIN_OFFSET;
 278         reg_set(hpipe_addr + HPIPE_INTERFACE_REG, data, mask);
 279
 280         /* Set Idle_sync enable */
 281         mask = HPIPE_PCIE_IDLE_SYNC_MASK;
 282         data = 0x1 << HPIPE_PCIE_IDLE_SYNC_OFFSET;
 283         /* Select bits for PCIE Gen3(32bit) */
 284         mask |= HPIPE_PCIE_SEL_BITS_MASK;
 285         data |= 0x2 << HPIPE_PCIE_SEL_BITS_OFFSET;
 286         reg_set(hpipe_addr + HPIPE_PCIE_REG0, data, mask);
 287
 288         /* Enable Tx_adapt_g1 */
 289         mask = HPIPE_TX_TRAIN_CTRL_G1_MASK;
 290         data = 0x1 << HPIPE_TX_TRAIN_CTRL_G1_OFFSET;
 291         /* Enable Tx_adapt_gn1 */
 292         mask |= HPIPE_TX_TRAIN_CTRL_GN1_MASK;
 293         data |= 0x1 << HPIPE_TX_TRAIN_CTRL_GN1_OFFSET;
 294         /* Disable Tx_adapt_g0 */
 295         mask |= HPIPE_TX_TRAIN_CTRL_G0_MASK;
 296         data |= 0x0 << HPIPE_TX_TRAIN_CTRL_G0_OFFSET;
 297         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_REG, data, mask);
 298
 299         /* Set reg_tx_train_chk_init */
 300         mask = HPIPE_TX_TRAIN_CHK_INIT_MASK;
 301         data = 0x0 << HPIPE_TX_TRAIN_CHK_INIT_OFFSET;
 302         /* Enable TX_COE_FM_PIN_PCIE3_EN */
 303         mask |= HPIPE_TX_TRAIN_COE_FM_PIN_PCIE3_MASK;
 304         data |= 0x1 << HPIPE_TX_TRAIN_COE_FM_PIN_PCIE3_OFFSET;
 305         reg_set(hpipe_addr + HPIPE_TX_TRAIN_REG, data, mask);
 306
 307         debug("stage: TRx training parameters\n");
 308         /* Set Preset sweep configurations */
 309         mask = HPIPE_TX_TX_STATUS_CHECK_MODE_MASK;
 310         data = 0x1 << HPIPE_TX_STATUS_CHECK_MODE_OFFSET;
 311
 312         mask |= HPIPE_TX_NUM_OF_PRESET_MASK;
 313         data |= 0x7 << HPIPE_TX_NUM_OF_PRESET_OFFSET;
 314
 315         mask |= HPIPE_TX_SWEEP_PRESET_EN_MASK;
 316         data |= 0x1 << HPIPE_TX_SWEEP_PRESET_EN_OFFSET;
 317         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_11_REG, data, mask);
 318
 319         /* Tx train start configuration */
 320         mask = HPIPE_TX_TRAIN_START_SQ_EN_MASK;
 321         data = 0x1 << HPIPE_TX_TRAIN_START_SQ_EN_OFFSET;
 322
 323         mask |= HPIPE_TX_TRAIN_START_FRM_DET_EN_MASK;
 324         data |= 0x0 << HPIPE_TX_TRAIN_START_FRM_DET_EN_OFFSET;
 325
 326         mask |= HPIPE_TX_TRAIN_START_FRM_LOCK_EN_MASK;
 327         data |= 0x0 << HPIPE_TX_TRAIN_START_FRM_LOCK_EN_OFFSET;
 328
 329         mask |= HPIPE_TX_TRAIN_WAIT_TIME_EN_MASK;
 330         data |= 0x1 << HPIPE_TX_TRAIN_WAIT_TIME_EN_OFFSET;
 331         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_5_REG, data, mask);
 332
 333         /* Enable Tx train P2P */
 334         mask = HPIPE_TX_TRAIN_P2P_HOLD_MASK;
 335         data = 0x1 << HPIPE_TX_TRAIN_P2P_HOLD_OFFSET;
 336         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_0_REG, data, mask);
 337
 338         /* Configure Tx train timeout */
 339         mask = HPIPE_TRX_TRAIN_TIMER_MASK;
 340         data = 0x17 << HPIPE_TRX_TRAIN_TIMER_OFFSET;
 341         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_4_REG, data, mask);
 342
 343         /* Disable G0/G1/GN1 adaptation */
 344         mask = HPIPE_TX_TRAIN_CTRL_G1_MASK | HPIPE_TX_TRAIN_CTRL_GN1_MASK
 345                 | HPIPE_TX_TRAIN_CTRL_G0_OFFSET;
 346         data = 0;
 347         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_REG, data, mask);
 348
 349         /* Disable DTL frequency loop */
 350         mask = HPIPE_PWR_CTR_DTL_FLOOP_EN_MASK;
 351         data = 0x0 << HPIPE_PWR_CTR_DTL_FLOOP_EN_OFFSET;
 352         reg_set(hpipe_addr + HPIPE_PWR_CTR_DTL_REG, data, mask);
 353
 354         /* Configure G3 DFE */
 355         mask = HPIPE_G3_DFE_RES_MASK;
 356         data = 0x3 << HPIPE_G3_DFE_RES_OFFSET;
 357         reg_set(hpipe_addr + HPIPE_G3_SETTING_4_REG, data, mask);
 358
 359         /* Use TX/RX training result for DFE */
 360         mask = HPIPE_DFE_RES_FORCE_MASK;
 361         data = 0x0 << HPIPE_DFE_RES_FORCE_OFFSET;
 362         reg_set(hpipe_addr + HPIPE_DFE_REG0,  data, mask);
 363
 364         /* Configure initial and final coefficient value for receiver */
 365         mask = HPIPE_G3_SET_1_G3_RX_SELMUPI_MASK;
 366         data = 0x1 << HPIPE_G3_SET_1_G3_RX_SELMUPI_OFFSET;
 367
 368         mask |= HPIPE_G3_SET_1_G3_RX_SELMUPF_MASK;
 369         data |= 0x1 << HPIPE_G3_SET_1_G3_RX_SELMUPF_OFFSET;
 370
 371         mask |= HPIPE_G3_SET_1_G3_SAMPLER_INPAIRX2_EN_MASK;
 372         data |= 0x0 << HPIPE_G3_SET_1_G3_SAMPLER_INPAIRX2_EN_OFFSET;
 373         reg_set(hpipe_addr + HPIPE_G3_SET_1_REG,  data, mask);
 374
 375         /* Trigger sampler enable pulse */
 376         mask = HPIPE_SMAPLER_MASK;
 377         data = 0x1 << HPIPE_SMAPLER_OFFSET;
 378         reg_set(hpipe_addr + HPIPE_SAMPLER_N_PROC_CALIB_CTRL_REG, data, mask);
 379         udelay(5);
 380         reg_set(hpipe_addr + HPIPE_SAMPLER_N_PROC_CALIB_CTRL_REG, 0, mask);
 381
 382         /* FFE resistor tuning for different bandwidth  */
 383         mask = HPIPE_G3_FFE_DEG_RES_LEVEL_MASK;
 384         data = 0x1 << HPIPE_G3_FFE_DEG_RES_LEVEL_OFFSET;
 385
 386         mask |= HPIPE_G3_FFE_LOAD_RES_LEVEL_MASK;
 387         data |= 0x3 << HPIPE_G3_FFE_LOAD_RES_LEVEL_OFFSET;
 388         reg_set(hpipe_addr + HPIPE_G3_SETTING_3_REG, data, mask);
 389
 390         /* Pattern lock lost timeout disable */
 391         mask = HPIPE_PATTERN_LOCK_LOST_TIMEOUT_EN_MASK;
 392         data = 0x0 << HPIPE_PATTERN_LOCK_LOST_TIMEOUT_EN_OFFSET;
 393         reg_set(hpipe_addr + HPIPE_FRAME_DETECT_CTRL_3_REG, data, mask);
 394
 395         /* Configure DFE adaptations */
 396         mask = HPIPE_CDR_MAX_DFE_ADAPT_1_MASK;
 397         data = 0x1 << HPIPE_CDR_MAX_DFE_ADAPT_1_OFFSET;
 398         mask |= HPIPE_CDR_MAX_DFE_ADAPT_0_MASK;
 399         data |= 0x0 << HPIPE_CDR_MAX_DFE_ADAPT_0_OFFSET;
 400         mask |= HPIPE_CDR_RX_MAX_DFE_ADAPT_1_MASK;
 401         data |= 0x0 << HPIPE_CDR_RX_MAX_DFE_ADAPT_1_OFFSET;
 402         reg_set(hpipe_addr + HPIPE_CDR_CONTROL_REG, data, mask);
 403         mask = HPIPE_DFE_TX_MAX_DFE_ADAPT_MASK;
 404         data = 0x0 << HPIPE_DFE_TX_MAX_DFE_ADAPT_OFFSET;
 405         reg_set(hpipe_addr + HPIPE_DFE_CONTROL_REG, data, mask);
 406
 407         /* Genration 2 setting 1*/
 408         mask = HPIPE_G2_SET_1_G2_RX_SELMUPI_MASK;
 409         data = 0x0 << HPIPE_G2_SET_1_G2_RX_SELMUPI_OFFSET;
 410         mask |= HPIPE_G2_SET_1_G2_RX_SELMUPP_MASK;
 411         data |= 0x1 << HPIPE_G2_SET_1_G2_RX_SELMUPP_OFFSET;
 412         mask |= HPIPE_G2_SET_1_G2_RX_SELMUFI_MASK;
 413         data |= 0x0 << HPIPE_G2_SET_1_G2_RX_SELMUFI_OFFSET;
 414         reg_set(hpipe_addr + HPIPE_G2_SET_1_REG, data, mask);
 415
 416         /* DFE enable */
 417         mask = HPIPE_G2_DFE_RES_MASK;
 418         data = 0x3 << HPIPE_G2_DFE_RES_OFFSET;
 419         reg_set(hpipe_addr + HPIPE_G2_SETTINGS_4_REG, data, mask);
 420
 421         /* Configure DFE Resolution */
 422         mask = HPIPE_LANE_CFG4_DFE_EN_SEL_MASK;
 423         data = 0x1 << HPIPE_LANE_CFG4_DFE_EN_SEL_OFFSET;
 424         reg_set(hpipe_addr + HPIPE_LANE_CFG4_REG, data, mask);
 425
 426         /* VDD calibration control */
 427         mask = HPIPE_EXT_SELLV_RXSAMPL_MASK;
 428         data = 0x16 << HPIPE_EXT_SELLV_RXSAMPL_OFFSET;
 429         reg_set(hpipe_addr + HPIPE_VDD_CAL_CTRL_REG, data, mask);
 430
 431         /* Set PLL Charge-pump Current Control */
 432         mask = HPIPE_G3_SETTING_5_G3_ICP_MASK;
 433         data = 0x4 << HPIPE_G3_SETTING_5_G3_ICP_OFFSET;
 434         reg_set(hpipe_addr + HPIPE_G3_SETTING_5_REG, data, mask);
 435
 436         /* Set lane rqualization remote setting */
 437         mask = HPIPE_LANE_CFG_FOM_DIRN_OVERRIDE_MASK;
 438         data = 0x1 << HPIPE_LANE_CFG_FOM_DIRN_OVERRIDE_OFFSET;
 439         mask |= HPIPE_LANE_CFG_FOM_ONLY_MODE_MASK;
 440         data |= 0x1 << HPIPE_LANE_CFG_FOM_ONLY_MODE_OFFFSET;
 441         mask |= HPIPE_LANE_CFG_FOM_PRESET_VECTOR_MASK;
 442         data |= 0x2 << HPIPE_LANE_CFG_FOM_PRESET_VECTOR_OFFSET;
 443         reg_set(hpipe_addr + HPIPE_LANE_EQ_REMOTE_SETTING_REG, data, mask);
 444
 445         if (!is_end_point) {
 446                 /* Set phy in root complex mode */
 447                 mask = HPIPE_CFG_PHY_RC_EP_MASK;
 448                 data = 0x1 << HPIPE_CFG_PHY_RC_EP_OFFSET;
 449                 reg_set(hpipe_addr + HPIPE_LANE_EQU_CONFIG_0_REG, data, mask);
 450         }
 451
 452         debug("stage: Comphy power up\n");
 453
 454         /*
 455          * For PCIe by4 or by2 - release from reset only after finish to
 456          * configure all lanes
 457          */
 458         if ((pcie_width == 1) || (lane == (pcie_width - 1))) {
 459                 u32 i, start_lane, end_lane;
 460
 461                 if (pcie_width != 1) {
 462                         /* allows writing to all lanes in one write */
 463                         reg_set(comphy_base + COMMON_PHY_SD_CTRL1,
 464                                 0x0 <<
 465                                 COMMON_PHY_SD_CTRL1_COMPHY_0_4_PORT_OFFSET,
 466                                 COMMON_PHY_SD_CTRL1_COMPHY_0_4_PORT_MASK);
 467                         start_lane = 0;
 468                         end_lane = pcie_width;
 469
 470                         /*
 471                          * Release from PIPE soft reset
 472                          * for PCIe by4 or by2 - release from soft reset
 473                          * all lanes - can't use read modify write
 474                          */
 475                         reg_set(HPIPE_ADDR(hpipe_base, 0) +
 476                                 HPIPE_RST_CLK_CTRL_REG, 0x24, 0xffffffff);
 477                 } else {
 478                         start_lane = lane;
 479                         end_lane = lane + 1;
 480
 481                         /*
 482                          * Release from PIPE soft reset
 483                          * for PCIe by4 or by2 - release from soft reset
 484                          * all lanes
 485                          */
 486                         reg_set(hpipe_addr + HPIPE_RST_CLK_CTRL_REG,
 487                                 0x0 << HPIPE_RST_CLK_CTRL_PIPE_RST_OFFSET,
 488                                 HPIPE_RST_CLK_CTRL_PIPE_RST_MASK);
 489                 }
 490
 491
 492                 if (pcie_width != 1) {
 493                         /* disable writing to all lanes with one write */
 494                         reg_set(comphy_base + COMMON_PHY_SD_CTRL1,
 495                                 0x3210 <<
 496                                 COMMON_PHY_SD_CTRL1_COMPHY_0_4_PORT_OFFSET,
 497                                 COMMON_PHY_SD_CTRL1_COMPHY_0_4_PORT_MASK);
 498                 }
 499
 500                 debug("stage: Check PLL\n");
 501                 /* Read lane status */
 502                 for (i = start_lane; i < end_lane; i++) {
 503                         addr = HPIPE_ADDR(hpipe_base, i) +
 504                                 HPIPE_LANE_STATUS1_REG;
 505                         data = HPIPE_LANE_STATUS1_PCLK_EN_MASK;
 506                         mask = data;
 507                         data = polling_with_timeout(addr, data, mask, 15000);
 508                         if (data != 0) {
 509                                 debug("Read from reg = %p - value = 0x%x\n",
 510                                       hpipe_addr + HPIPE_LANE_STATUS1_REG,
 511                                       data);
 512                                 pr_err("HPIPE_LANE_STATUS1_PCLK_EN_MASK is 0\n");
 513                                 ret = 0;
 514                         }
 515                 }
 516         }
 517
 518         debug_exit();
 519         return ret;
 520 }
 521
 522 static int comphy_usb3_power_up(u32 lane, void __iomem *hpipe_base,
 523                                 void __iomem *comphy_base)
 524 {
 525         u32 mask, data, ret = 1;
 526         void __iomem *hpipe_addr = HPIPE_ADDR(hpipe_base, lane);
 527         void __iomem *comphy_addr = COMPHY_ADDR(comphy_base, lane);
 528         void __iomem *addr;
 529
 530         debug_enter();
 531         debug("stage: RFU configurations - hard reset comphy\n");
 532         /* RFU configurations - hard reset comphy */
 533         mask = COMMON_PHY_CFG1_PWR_UP_MASK;
 534         data = 0x1 << COMMON_PHY_CFG1_PWR_UP_OFFSET;
 535         mask |= COMMON_PHY_CFG1_PIPE_SELECT_MASK;
 536         data |= 0x1 << COMMON_PHY_CFG1_PIPE_SELECT_OFFSET;
 537         mask |= COMMON_PHY_CFG1_PWR_ON_RESET_MASK;
 538         data |= 0x0 << COMMON_PHY_CFG1_PWR_ON_RESET_OFFSET;
 539         mask |= COMMON_PHY_CFG1_CORE_RSTN_MASK;
 540         data |= 0x0 << COMMON_PHY_CFG1_CORE_RSTN_OFFSET;
 541         mask |= COMMON_PHY_PHY_MODE_MASK;
 542         data |= 0x1 << COMMON_PHY_PHY_MODE_OFFSET;
 543         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
 544
 545         /* release from hard reset */
 546         mask = COMMON_PHY_CFG1_PWR_ON_RESET_MASK;
 547         data = 0x1 << COMMON_PHY_CFG1_PWR_ON_RESET_OFFSET;
 548         mask |= COMMON_PHY_CFG1_CORE_RSTN_MASK;
 549         data |= 0x1 << COMMON_PHY_CFG1_CORE_RSTN_OFFSET;
 550         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
 551
 552         /* Wait 1ms - until band gap and ref clock ready */
 553         mdelay(1);
 554
 555         /* Start comphy Configuration */
 556         debug("stage: Comphy configuration\n");
 557         /* Set PIPE soft reset */
 558         mask = HPIPE_RST_CLK_CTRL_PIPE_RST_MASK;
 559         data = 0x1 << HPIPE_RST_CLK_CTRL_PIPE_RST_OFFSET;
 560         /* Set PHY datapath width mode for V0 */
 561         mask |= HPIPE_RST_CLK_CTRL_FIXED_PCLK_MASK;
 562         data |= 0x0 << HPIPE_RST_CLK_CTRL_FIXED_PCLK_OFFSET;
 563         /* Set Data bus width USB mode for V0 */
 564         mask |= HPIPE_RST_CLK_CTRL_PIPE_WIDTH_MASK;
 565         data |= 0x0 << HPIPE_RST_CLK_CTRL_PIPE_WIDTH_OFFSET;
 566         /* Set CORE_CLK output frequency for 250Mhz */
 567         mask |= HPIPE_RST_CLK_CTRL_CORE_FREQ_SEL_MASK;
 568         data |= 0x0 << HPIPE_RST_CLK_CTRL_CORE_FREQ_SEL_OFFSET;
 569         reg_set(hpipe_addr + HPIPE_RST_CLK_CTRL_REG, data, mask);
 570         /* Set PLL ready delay for 0x2 */
 571         reg_set(hpipe_addr + HPIPE_CLK_SRC_LO_REG,
 572                 0x2 << HPIPE_CLK_SRC_LO_PLL_RDY_DL_OFFSET,
 573                 HPIPE_CLK_SRC_LO_PLL_RDY_DL_MASK);
 574         /* Set reference clock to come from group 1 - 25Mhz */
 575         reg_set(hpipe_addr + HPIPE_MISC_REG,
 576                 0x0 << HPIPE_MISC_REFCLK_SEL_OFFSET,
 577                 HPIPE_MISC_REFCLK_SEL_MASK);
 578         /* Set reference frequcency select - 0x2 */
 579         mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
 580         data = 0x2 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
 581         /* Set PHY mode to USB - 0x5 */
 582         mask |= HPIPE_PWR_PLL_PHY_MODE_MASK;
 583         data |= 0x5 << HPIPE_PWR_PLL_PHY_MODE_OFFSET;
 584         reg_set(hpipe_addr + HPIPE_PWR_PLL_REG, data, mask);
 585         /* Set the amount of time spent in the LoZ state - set for 0x7 */
 586         reg_set(hpipe_addr + HPIPE_GLOBAL_PM_CTRL,
 587                 0x7 << HPIPE_GLOBAL_PM_RXDLOZ_WAIT_OFFSET,
 588                 HPIPE_GLOBAL_PM_RXDLOZ_WAIT_MASK);
 589         /* Set max PHY generation setting - 5Gbps */
 590         reg_set(hpipe_addr + HPIPE_INTERFACE_REG,
 591                 0x1 << HPIPE_INTERFACE_GEN_MAX_OFFSET,
 592                 HPIPE_INTERFACE_GEN_MAX_MASK);
 593         /* Set select data width 20Bit (SEL_BITS[2:0]) */
 594         reg_set(hpipe_addr + HPIPE_LOOPBACK_REG,
 595                 0x1 << HPIPE_LOOPBACK_SEL_OFFSET,
 596                 HPIPE_LOOPBACK_SEL_MASK);
 597         /* select de-emphasize 3.5db */
 598         reg_set(hpipe_addr + HPIPE_LANE_CONFIG0_REG,
 599                 0x1 << HPIPE_LANE_CONFIG0_TXDEEMPH0_OFFSET,
 600                 HPIPE_LANE_CONFIG0_TXDEEMPH0_MASK);
 601         /* override tx margining from the MAC */
 602         reg_set(hpipe_addr + HPIPE_TST_MODE_CTRL_REG,
 603                 0x1 << HPIPE_TST_MODE_CTRL_MODE_MARGIN_OFFSET,
 604                 HPIPE_TST_MODE_CTRL_MODE_MARGIN_MASK);
 605
 606         /* Start analog paramters from ETP(HW) */
 607         debug("stage: Analog paramters from ETP(HW)\n");
 608         /* Set Pin DFE_PAT_DIS -> Bit[1]: PIN_DFE_PAT_DIS = 0x0 */
 609         mask = HPIPE_LANE_CFG4_DFE_CTRL_MASK;
 610         data = 0x1 << HPIPE_LANE_CFG4_DFE_CTRL_OFFSET;
 611         /* Set Override PHY DFE control pins for 0x1 */
 612         mask |= HPIPE_LANE_CFG4_DFE_OVER_MASK;
 613         data |= 0x1 << HPIPE_LANE_CFG4_DFE_OVER_OFFSET;
 614         /* Set Spread Spectrum Clock Enable fot 0x1 */
 615         mask |= HPIPE_LANE_CFG4_SSC_CTRL_MASK;
 616         data |= 0x1 << HPIPE_LANE_CFG4_SSC_CTRL_OFFSET;
 617         reg_set(hpipe_addr + HPIPE_LANE_CFG4_REG, data, mask);
 618         /* End of analog parameters */
 619
 620         debug("stage: Comphy power up\n");
 621         /* Release from PIPE soft reset */
 622         reg_set(hpipe_addr + HPIPE_RST_CLK_CTRL_REG,
 623                 0x0 << HPIPE_RST_CLK_CTRL_PIPE_RST_OFFSET,
 624                 HPIPE_RST_CLK_CTRL_PIPE_RST_MASK);
 625
 626         /* wait 15ms - for comphy calibration done */
 627         debug("stage: Check PLL\n");
 628         /* Read lane status */
 629         addr = hpipe_addr + HPIPE_LANE_STATUS1_REG;
 630         data = HPIPE_LANE_STATUS1_PCLK_EN_MASK;
 631         mask = data;
 632         data = polling_with_timeout(addr, data, mask, 15000);
 633         if (data != 0) {
 634                 debug("Read from reg = %p - value = 0x%x\n",
 635                       hpipe_addr + HPIPE_LANE_STATUS1_REG, data);
 636                 pr_err("HPIPE_LANE_STATUS1_PCLK_EN_MASK is 0\n");
 637                 ret = 0;
 638         }
 639
 640         debug_exit();
 641         return ret;
 642 }
 643
 644 static int comphy_sata_power_up(u32 lane, void __iomem *hpipe_base,
 645                                 void __iomem *comphy_base, int cp_index,
 646                                 u32 invert)
 647 {
 648         u32 mask, data, i, ret = 1;
 649         void __iomem *hpipe_addr = HPIPE_ADDR(hpipe_base, lane);
 650         void __iomem *sd_ip_addr = SD_ADDR(hpipe_base, lane);
 651         void __iomem *comphy_addr = COMPHY_ADDR(comphy_base, lane);
 652         void __iomem *addr;
 653         void __iomem *sata_base = NULL;
 654         int sata_node = -1; /* Set to -1 in order to read the first sata node */
 655
 656         debug_enter();
 657
 658         /*
 659          * Assumption - each CP has only one SATA controller
 660          * Calling fdt_node_offset_by_compatible first time (with sata_node = -1
 661          * will return the first node always.
 662          * In order to parse each CPs SATA node, fdt_node_offset_by_compatible
 663          * must be called again (according to the CP id)
 664          */
 665         for (i = 0; i < (cp_index + 1); i++)
 666                 sata_node = fdt_node_offset_by_compatible(
 667                         gd->fdt_blob, sata_node, "marvell,armada-8k-ahci");
 668
 669         if (sata_node == 0) {
 670                 pr_err("SATA node not found in FDT\n");
 671                 return 0;
 672         }
 673
 674         sata_base = (void __iomem *)fdtdec_get_addr_size_auto_noparent(
 675                 gd->fdt_blob, sata_node, "reg", 0, NULL, true);
 676         if (sata_base == NULL) {
 677                 pr_err("SATA address not found in FDT\n");
 678                 return 0;
 679         }
 680
 681         debug("SATA address found in FDT %p\n", sata_base);
 682
 683         debug("stage: MAC configuration - power down comphy\n");
 684         /*
 685          * MAC configuration powe down comphy use indirect address for
 686          * vendor spesific SATA control register
 687          */
 688         reg_set(sata_base + SATA3_VENDOR_ADDRESS,
 689                 SATA_CONTROL_REG << SATA3_VENDOR_ADDR_OFSSET,
 690                 SATA3_VENDOR_ADDR_MASK);
 691         /* SATA 0 power down */
 692         mask = SATA3_CTRL_SATA0_PD_MASK;
 693         data = 0x1 << SATA3_CTRL_SATA0_PD_OFFSET;
 694         /* SATA 1 power down */
 695         mask |= SATA3_CTRL_SATA1_PD_MASK;
 696         data |= 0x1 << SATA3_CTRL_SATA1_PD_OFFSET;
 697         /* SATA SSU disable */
 698         mask |= SATA3_CTRL_SATA1_ENABLE_MASK;
 699         data |= 0x0 << SATA3_CTRL_SATA1_ENABLE_OFFSET;
 700         /* SATA port 1 disable */
 701         mask |= SATA3_CTRL_SATA_SSU_MASK;
 702         data |= 0x0 << SATA3_CTRL_SATA_SSU_OFFSET;
 703         reg_set(sata_base + SATA3_VENDOR_DATA, data, mask);
 704
 705         debug("stage: RFU configurations - hard reset comphy\n");
 706         /* RFU configurations - hard reset comphy */
 707         mask = COMMON_PHY_CFG1_PWR_UP_MASK;
 708         data = 0x1 << COMMON_PHY_CFG1_PWR_UP_OFFSET;
 709         mask |= COMMON_PHY_CFG1_PIPE_SELECT_MASK;
 710         data |= 0x0 << COMMON_PHY_CFG1_PIPE_SELECT_OFFSET;
 711         mask |= COMMON_PHY_CFG1_PWR_ON_RESET_MASK;
 712         data |= 0x0 << COMMON_PHY_CFG1_PWR_ON_RESET_OFFSET;
 713         mask |= COMMON_PHY_CFG1_CORE_RSTN_MASK;
 714         data |= 0x0 << COMMON_PHY_CFG1_CORE_RSTN_OFFSET;
 715         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
 716
 717         /* Set select data  width 40Bit - SATA mode only */
 718         reg_set(comphy_addr + COMMON_PHY_CFG6_REG,
 719                 0x1 << COMMON_PHY_CFG6_IF_40_SEL_OFFSET,
 720                 COMMON_PHY_CFG6_IF_40_SEL_MASK);
 721
 722         /* release from hard reset in SD external */
 723         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
 724         data = 0x1 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
 725         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
 726         data |= 0x1 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
 727         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
 728
 729         /* Wait 1ms - until band gap and ref clock ready */
 730         mdelay(1);
 731
 732         debug("stage: Comphy configuration\n");
 733         /* Start comphy Configuration */
 734         /* Set reference clock to comes from group 1 - choose 25Mhz */
 735         reg_set(hpipe_addr + HPIPE_MISC_REG,
 736                 0x0 << HPIPE_MISC_REFCLK_SEL_OFFSET,
 737                 HPIPE_MISC_REFCLK_SEL_MASK);
 738         /* Reference frequency select set 1 (for SATA = 25Mhz) */
 739         mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
 740         data = 0x1 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
 741         /* PHY mode select (set SATA = 0x0 */
 742         mask |= HPIPE_PWR_PLL_PHY_MODE_MASK;
 743         data |= 0x0 << HPIPE_PWR_PLL_PHY_MODE_OFFSET;
 744         reg_set(hpipe_addr + HPIPE_PWR_PLL_REG, data, mask);
 745         /* Set max PHY generation setting - 6Gbps */
 746         reg_set(hpipe_addr + HPIPE_INTERFACE_REG,
 747                 0x2 << HPIPE_INTERFACE_GEN_MAX_OFFSET,
 748                 HPIPE_INTERFACE_GEN_MAX_MASK);
 749         /* Set select data  width 40Bit (SEL_BITS[2:0]) */
 750         reg_set(hpipe_addr + HPIPE_LOOPBACK_REG,
 751                 0x2 << HPIPE_LOOPBACK_SEL_OFFSET, HPIPE_LOOPBACK_SEL_MASK);
 752
 753         debug("stage: Analog paramters from ETP(HW)\n");
 754         /* Set analog parameters from ETP(HW) */
 755         /* G1 settings */
 756         mask = HPIPE_G1_SET_1_G1_RX_SELMUPI_MASK;
 757         data = 0x0 << HPIPE_G1_SET_1_G1_RX_SELMUPI_OFFSET;
 758         mask |= HPIPE_G1_SET_1_G1_RX_SELMUPP_MASK;
 759         data |= 0x1 << HPIPE_G1_SET_1_G1_RX_SELMUPP_OFFSET;
 760         mask |= HPIPE_G1_SET_1_G1_RX_SELMUFI_MASK;
 761         data |= 0x0 << HPIPE_G1_SET_1_G1_RX_SELMUFI_OFFSET;
 762         mask |= HPIPE_G1_SET_1_G1_RX_SELMUFF_MASK;
 763         data |= 0x3 << HPIPE_G1_SET_1_G1_RX_SELMUFF_OFFSET;
 764         mask |= HPIPE_G1_SET_1_G1_RX_DIGCK_DIV_MASK;
 765         data |= 0x1 << HPIPE_G1_SET_1_G1_RX_DIGCK_DIV_OFFSET;
 766         reg_set(hpipe_addr + HPIPE_G1_SET_1_REG, data, mask);
 767
 768         mask = HPIPE_G1_SETTINGS_3_G1_FFE_CAP_SEL_MASK;
 769         data = 0xf << HPIPE_G1_SETTINGS_3_G1_FFE_CAP_SEL_OFFSET;
 770         mask |= HPIPE_G1_SETTINGS_3_G1_FFE_RES_SEL_MASK;
 771         data |= 0x2 << HPIPE_G1_SETTINGS_3_G1_FFE_RES_SEL_OFFSET;
 772         mask |= HPIPE_G1_SETTINGS_3_G1_FFE_SETTING_FORCE_MASK;
 773         data |= 0x1 << HPIPE_G1_SETTINGS_3_G1_FFE_SETTING_FORCE_OFFSET;
 774         mask |= HPIPE_G1_SETTINGS_3_G1_FFE_DEG_RES_LEVEL_MASK;
 775         data |= 0x1 << HPIPE_G1_SETTINGS_3_G1_FFE_DEG_RES_LEVEL_OFFSET;
 776         mask |= HPIPE_G1_SETTINGS_3_G1_FFE_LOAD_RES_LEVEL_MASK;
 777         data |= 0x1 << HPIPE_G1_SETTINGS_3_G1_FFE_LOAD_RES_LEVEL_OFFSET;
 778         reg_set(hpipe_addr + HPIPE_G1_SETTINGS_3_REG, data, mask);
 779
 780         /* G2 settings */
 781         mask = HPIPE_G2_SET_1_G2_RX_SELMUPI_MASK;
 782         data = 0x0 << HPIPE_G2_SET_1_G2_RX_SELMUPI_OFFSET;
 783         mask |= HPIPE_G2_SET_1_G2_RX_SELMUPP_MASK;
 784         data |= 0x1 << HPIPE_G2_SET_1_G2_RX_SELMUPP_OFFSET;
 785         mask |= HPIPE_G2_SET_1_G2_RX_SELMUFI_MASK;
 786         data |= 0x0 << HPIPE_G2_SET_1_G2_RX_SELMUFI_OFFSET;
 787         mask |= HPIPE_G2_SET_1_G2_RX_SELMUFF_MASK;
 788         data |= 0x3 << HPIPE_G2_SET_1_G2_RX_SELMUFF_OFFSET;
 789         mask |= HPIPE_G2_SET_1_G2_RX_DIGCK_DIV_MASK;
 790         data |= 0x1 << HPIPE_G2_SET_1_G2_RX_DIGCK_DIV_OFFSET;
 791         reg_set(hpipe_addr + HPIPE_G2_SET_1_REG, data, mask);
 792
 793         /* G3 settings */
 794         mask = HPIPE_G3_SET_1_G3_RX_SELMUPI_MASK;
 795         data = 0x2 << HPIPE_G3_SET_1_G3_RX_SELMUPI_OFFSET;
 796         mask |= HPIPE_G3_SET_1_G3_RX_SELMUPF_MASK;
 797         data |= 0x2 << HPIPE_G3_SET_1_G3_RX_SELMUPF_OFFSET;
 798         mask |= HPIPE_G3_SET_1_G3_RX_SELMUFI_MASK;
 799         data |= 0x3 << HPIPE_G3_SET_1_G3_RX_SELMUFI_OFFSET;
 800         mask |= HPIPE_G3_SET_1_G3_RX_SELMUFF_MASK;
 801         data |= 0x3 << HPIPE_G3_SET_1_G3_RX_SELMUFF_OFFSET;
 802         mask |= HPIPE_G3_SET_1_G3_RX_DFE_EN_MASK;
 803         data |= 0x1 << HPIPE_G3_SET_1_G3_RX_DFE_EN_OFFSET;
 804         mask |= HPIPE_G3_SET_1_G3_RX_DIGCK_DIV_MASK;
 805         data |= 0x2 << HPIPE_G3_SET_1_G3_RX_DIGCK_DIV_OFFSET;
 806         mask |= HPIPE_G3_SET_1_G3_SAMPLER_INPAIRX2_EN_MASK;
 807         data |= 0x0 << HPIPE_G3_SET_1_G3_SAMPLER_INPAIRX2_EN_OFFSET;
 808         reg_set(hpipe_addr + HPIPE_G3_SET_1_REG, data, mask);
 809
 810         /* DTL Control */
 811         mask = HPIPE_PWR_CTR_DTL_SQ_DET_EN_MASK;
 812         data = 0x1 << HPIPE_PWR_CTR_DTL_SQ_DET_EN_OFFSET;
 813         mask |= HPIPE_PWR_CTR_DTL_SQ_PLOOP_EN_MASK;
 814         data |= 0x1 << HPIPE_PWR_CTR_DTL_SQ_PLOOP_EN_OFFSET;
 815         mask |= HPIPE_PWR_CTR_DTL_FLOOP_EN_MASK;
 816         data |= 0x1 << HPIPE_PWR_CTR_DTL_FLOOP_EN_OFFSET;
 817         mask |= HPIPE_PWR_CTR_DTL_CLAMPING_SEL_MASK;
 818         data |= 0x1 << HPIPE_PWR_CTR_DTL_CLAMPING_SEL_OFFSET;
 819         mask |= HPIPE_PWR_CTR_DTL_INTPCLK_DIV_FORCE_MASK;
 820         data |= 0x1 << HPIPE_PWR_CTR_DTL_INTPCLK_DIV_FORCE_OFFSET;
 821         mask |= HPIPE_PWR_CTR_DTL_CLK_MODE_MASK;
 822         data |= 0x1 << HPIPE_PWR_CTR_DTL_CLK_MODE_OFFSET;
 823         mask |= HPIPE_PWR_CTR_DTL_CLK_MODE_FORCE_MASK;
 824         data |= 0x1 << HPIPE_PWR_CTR_DTL_CLK_MODE_FORCE_OFFSET;
 825         reg_set(hpipe_addr + HPIPE_PWR_CTR_DTL_REG, data, mask);
 826
 827         /* Trigger sampler enable pulse (by toggleing the bit) */
 828         mask = HPIPE_SMAPLER_MASK;
 829         data = 0x1 << HPIPE_SMAPLER_OFFSET;
 830         reg_set(hpipe_addr + HPIPE_SAMPLER_N_PROC_CALIB_CTRL_REG, data, mask);
 831         mask = HPIPE_SMAPLER_MASK;
 832         data = 0x0 << HPIPE_SMAPLER_OFFSET;
 833         reg_set(hpipe_addr + HPIPE_SAMPLER_N_PROC_CALIB_CTRL_REG, data, mask);
 834
 835         /* VDD Calibration Control 3 */
 836         mask = HPIPE_EXT_SELLV_RXSAMPL_MASK;
 837         data = 0x10 << HPIPE_EXT_SELLV_RXSAMPL_OFFSET;
 838         reg_set(hpipe_addr + HPIPE_VDD_CAL_CTRL_REG, data, mask);
 839
 840         /* DFE Resolution Control */
 841         mask = HPIPE_DFE_RES_FORCE_MASK;
 842         data = 0x1 << HPIPE_DFE_RES_FORCE_OFFSET;
 843         reg_set(hpipe_addr + HPIPE_DFE_REG0, data, mask);
 844
 845         /* DFE F3-F5 Coefficient Control */
 846         mask = HPIPE_DFE_F3_F5_DFE_EN_MASK;
 847         data = 0x0 << HPIPE_DFE_F3_F5_DFE_EN_OFFSET;
 848         mask |= HPIPE_DFE_F3_F5_DFE_CTRL_MASK;
 849         data = 0x0 << HPIPE_DFE_F3_F5_DFE_CTRL_OFFSET;
 850         reg_set(hpipe_addr + HPIPE_DFE_F3_F5_REG, data, mask);
 851
 852         /* G3 Setting 3 */
 853         mask = HPIPE_G3_FFE_CAP_SEL_MASK;
 854         data = 0xf << HPIPE_G3_FFE_CAP_SEL_OFFSET;
 855         mask |= HPIPE_G3_FFE_RES_SEL_MASK;
 856         data |= 0x4 << HPIPE_G3_FFE_RES_SEL_OFFSET;
 857         mask |= HPIPE_G3_FFE_SETTING_FORCE_MASK;
 858         data |= 0x1 << HPIPE_G3_FFE_SETTING_FORCE_OFFSET;
 859         mask |= HPIPE_G3_FFE_DEG_RES_LEVEL_MASK;
 860         data |= 0x1 << HPIPE_G3_FFE_DEG_RES_LEVEL_OFFSET;
 861         mask |= HPIPE_G3_FFE_LOAD_RES_LEVEL_MASK;
 862         data |= 0x3 << HPIPE_G3_FFE_LOAD_RES_LEVEL_OFFSET;
 863         reg_set(hpipe_addr + HPIPE_G3_SETTING_3_REG, data, mask);
 864
 865         /* G3 Setting 4 */
 866         mask = HPIPE_G3_DFE_RES_MASK;
 867         data = 0x2 << HPIPE_G3_DFE_RES_OFFSET;
 868         reg_set(hpipe_addr + HPIPE_G3_SETTING_4_REG, data, mask);
 869
 870         /* Offset Phase Control */
 871         mask = HPIPE_OS_PH_OFFSET_MASK;
 872         data = 0x5c << HPIPE_OS_PH_OFFSET_OFFSET;
 873         mask |= HPIPE_OS_PH_OFFSET_FORCE_MASK;
 874         data |= 0x1 << HPIPE_OS_PH_OFFSET_FORCE_OFFSET;
 875         reg_set(hpipe_addr + HPIPE_PHASE_CONTROL_REG, data, mask);
 876         mask = HPIPE_OS_PH_VALID_MASK;
 877         data = 0x1 << HPIPE_OS_PH_VALID_OFFSET;
 878         reg_set(hpipe_addr + HPIPE_PHASE_CONTROL_REG, data, mask);
 879         mask = HPIPE_OS_PH_VALID_MASK;
 880         data = 0x0 << HPIPE_OS_PH_VALID_OFFSET;
 881         reg_set(hpipe_addr + HPIPE_PHASE_CONTROL_REG, data, mask);
 882
 883         /* Set G1 TX amplitude and TX post emphasis value */
 884         mask = HPIPE_G1_SET_0_G1_TX_AMP_MASK;
 885         data = 0x8 << HPIPE_G1_SET_0_G1_TX_AMP_OFFSET;
 886         mask |= HPIPE_G1_SET_0_G1_TX_AMP_ADJ_MASK;
 887         data |= 0x1 << HPIPE_G1_SET_0_G1_TX_AMP_ADJ_OFFSET;
 888         mask |= HPIPE_G1_SET_0_G1_TX_EMPH1_MASK;
 889         data |= 0x1 << HPIPE_G1_SET_0_G1_TX_EMPH1_OFFSET;
 890         mask |= HPIPE_G1_SET_0_G1_TX_EMPH1_EN_MASK;
 891         data |= 0x1 << HPIPE_G1_SET_0_G1_TX_EMPH1_EN_OFFSET;
 892         reg_set(hpipe_addr + HPIPE_G1_SET_0_REG, data, mask);
 893
 894         /* Set G2 TX amplitude and TX post emphasis value */
 895         mask = HPIPE_G2_SET_0_G2_TX_AMP_MASK;
 896         data = 0xa << HPIPE_G2_SET_0_G2_TX_AMP_OFFSET;
 897         mask |= HPIPE_G2_SET_0_G2_TX_AMP_ADJ_MASK;
 898         data |= 0x1 << HPIPE_G2_SET_0_G2_TX_AMP_ADJ_OFFSET;
 899         mask |= HPIPE_G2_SET_0_G2_TX_EMPH1_MASK;
 900         data |= 0x2 << HPIPE_G2_SET_0_G2_TX_EMPH1_OFFSET;
 901         mask |= HPIPE_G2_SET_0_G2_TX_EMPH1_EN_MASK;
 902         data |= 0x1 << HPIPE_G2_SET_0_G2_TX_EMPH1_EN_OFFSET;
 903         reg_set(hpipe_addr + HPIPE_G2_SET_0_REG, data, mask);
 904
 905         /* Set G3 TX amplitude and TX post emphasis value */
 906         mask = HPIPE_G3_SET_0_G3_TX_AMP_MASK;
 907         data = 0xe << HPIPE_G3_SET_0_G3_TX_AMP_OFFSET;
 908         mask |= HPIPE_G3_SET_0_G3_TX_AMP_ADJ_MASK;
 909         data |= 0x1 << HPIPE_G3_SET_0_G3_TX_AMP_ADJ_OFFSET;
 910         mask |= HPIPE_G3_SET_0_G3_TX_EMPH1_MASK;
 911         data |= 0x6 << HPIPE_G3_SET_0_G3_TX_EMPH1_OFFSET;
 912         mask |= HPIPE_G3_SET_0_G3_TX_EMPH1_EN_MASK;
 913         data |= 0x1 << HPIPE_G3_SET_0_G3_TX_EMPH1_EN_OFFSET;
 914         mask |= HPIPE_G3_SET_0_G3_TX_SLEW_RATE_SEL_MASK;
 915         data |= 0x4 << HPIPE_G3_SET_0_G3_TX_SLEW_RATE_SEL_OFFSET;
 916         mask |= HPIPE_G3_SET_0_G3_TX_SLEW_CTRL_EN_MASK;
 917         data |= 0x0 << HPIPE_G3_SET_0_G3_TX_SLEW_CTRL_EN_OFFSET;
 918         reg_set(hpipe_addr + HPIPE_G3_SET_0_REG, data, mask);
 919
 920         /* SERDES External Configuration 2 register */
 921         mask = SD_EXTERNAL_CONFIG2_SSC_ENABLE_MASK;
 922         data = 0x1 << SD_EXTERNAL_CONFIG2_SSC_ENABLE_OFFSET;
 923         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG2_REG, data, mask);
 924
 925         /* DFE reset sequence */
 926         reg_set(hpipe_addr + HPIPE_PWR_CTR_REG,
 927                 0x1 << HPIPE_PWR_CTR_RST_DFE_OFFSET,
 928                 HPIPE_PWR_CTR_RST_DFE_MASK);
 929         reg_set(hpipe_addr + HPIPE_PWR_CTR_REG,
 930                 0x0 << HPIPE_PWR_CTR_RST_DFE_OFFSET,
 931                 HPIPE_PWR_CTR_RST_DFE_MASK);
 932
 933         /* Set RX / TX swaps */
 934         data = mask = 0;
 935         if (invert & PHY_POLARITY_TXD_INVERT) {
 936                 data |= (1 << HPIPE_SYNC_PATTERN_TXD_SWAP_OFFSET);
 937                 mask |= HPIPE_SYNC_PATTERN_TXD_SWAP_MASK;
 938         }
 939         if (invert & PHY_POLARITY_RXD_INVERT) {
 940                 data |= (1 << HPIPE_SYNC_PATTERN_RXD_SWAP_OFFSET);
 941                 mask |= HPIPE_SYNC_PATTERN_RXD_SWAP_MASK;
 942         }
 943         reg_set(hpipe_addr + HPIPE_SYNC_PATTERN_REG, data, mask);
 944
 945         /* SW reset for interupt logic */
 946         reg_set(hpipe_addr + HPIPE_PWR_CTR_REG,
 947                 0x1 << HPIPE_PWR_CTR_SFT_RST_OFFSET,
 948                 HPIPE_PWR_CTR_SFT_RST_MASK);
 949         reg_set(hpipe_addr + HPIPE_PWR_CTR_REG,
 950                 0x0 << HPIPE_PWR_CTR_SFT_RST_OFFSET,
 951                 HPIPE_PWR_CTR_SFT_RST_MASK);
 952
 953         debug("stage: Comphy power up\n");
 954         /*
 955          * MAC configuration power up comphy - power up PLL/TX/RX
 956          * use indirect address for vendor spesific SATA control register
 957          */
 958         reg_set(sata_base + SATA3_VENDOR_ADDRESS,
 959                 SATA_CONTROL_REG << SATA3_VENDOR_ADDR_OFSSET,
 960                 SATA3_VENDOR_ADDR_MASK);
 961         /* SATA 0 power up */
 962         mask = SATA3_CTRL_SATA0_PD_MASK;
 963         data = 0x0 << SATA3_CTRL_SATA0_PD_OFFSET;
 964         /* SATA 1 power up */
 965         mask |= SATA3_CTRL_SATA1_PD_MASK;
 966         data |= 0x0 << SATA3_CTRL_SATA1_PD_OFFSET;
 967         /* SATA SSU enable */
 968         mask |= SATA3_CTRL_SATA1_ENABLE_MASK;
 969         data |= 0x1 << SATA3_CTRL_SATA1_ENABLE_OFFSET;
 970         /* SATA port 1 enable */
 971         mask |= SATA3_CTRL_SATA_SSU_MASK;
 972         data |= 0x1 << SATA3_CTRL_SATA_SSU_OFFSET;
 973         reg_set(sata_base + SATA3_VENDOR_DATA, data, mask);
 974
 975         /* MBUS request size and interface select register */
 976         reg_set(sata_base + SATA3_VENDOR_ADDRESS,
 977                 SATA_MBUS_SIZE_SELECT_REG << SATA3_VENDOR_ADDR_OFSSET,
 978                 SATA3_VENDOR_ADDR_MASK);
 979         /* Mbus regret enable */
 980         reg_set(sata_base + SATA3_VENDOR_DATA,
 981                 0x1 << SATA_MBUS_REGRET_EN_OFFSET, SATA_MBUS_REGRET_EN_MASK);
 982
 983         debug("stage: Check PLL\n");
 984
 985         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
 986         data = SD_EXTERNAL_STATUS0_PLL_TX_MASK &
 987                 SD_EXTERNAL_STATUS0_PLL_RX_MASK;
 988         mask = data;
 989         data = polling_with_timeout(addr, data, mask, 15000);
 990         if (data != 0) {
 991                 debug("Read from reg = %p - value = 0x%x\n",
 992                       hpipe_addr + HPIPE_LANE_STATUS1_REG, data);
 993                 pr_err("SD_EXTERNAL_STATUS0_PLL_TX is %d, SD_EXTERNAL_STATUS0_PLL_RX is %d\n",
 994                       (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK),
 995                       (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK));
 996                 ret = 0;
 997         }
 998
 999         debug_exit();
1000         return ret;
1001 }
1002
1003 static int comphy_sgmii_power_up(u32 lane, u32 sgmii_speed,
1004                                  void __iomem *hpipe_base,
1005                                  void __iomem *comphy_base)
1006 {
1007         u32 mask, data, ret = 1;
1008         void __iomem *hpipe_addr = HPIPE_ADDR(hpipe_base, lane);
1009         void __iomem *sd_ip_addr = SD_ADDR(hpipe_base, lane);
1010         void __iomem *comphy_addr = COMPHY_ADDR(comphy_base, lane);
1011         void __iomem *addr;
1012
1013         debug_enter();
1014         debug("stage: RFU configurations - hard reset comphy\n");
1015         /* RFU configurations - hard reset comphy */
1016         mask = COMMON_PHY_CFG1_PWR_UP_MASK;
1017         data = 0x1 << COMMON_PHY_CFG1_PWR_UP_OFFSET;
1018         mask |= COMMON_PHY_CFG1_PIPE_SELECT_MASK;
1019         data |= 0x0 << COMMON_PHY_CFG1_PIPE_SELECT_OFFSET;
1020         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
1021
1022         /* Select Baud Rate of Comphy And PD_PLL/Tx/Rx */
1023         mask = SD_EXTERNAL_CONFIG0_SD_PU_PLL_MASK;
1024         data = 0x0 << SD_EXTERNAL_CONFIG0_SD_PU_PLL_OFFSET;
1025         mask |= SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_MASK;
1026         mask |= SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_MASK;
1027         if (sgmii_speed == PHY_SPEED_1_25G) {
1028                 data |= 0x6 << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_OFFSET;
1029                 data |= 0x6 << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_OFFSET;
1030         } else {
1031                 /* 3.125G */
1032                 data |= 0x8 << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_OFFSET;
1033                 data |= 0x8 << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_OFFSET;
1034         }
1035         mask |= SD_EXTERNAL_CONFIG0_SD_PU_RX_MASK;
1036         data |= 0 << SD_EXTERNAL_CONFIG0_SD_PU_RX_OFFSET;
1037         mask |= SD_EXTERNAL_CONFIG0_SD_PU_TX_MASK;
1038         data |= 0 << SD_EXTERNAL_CONFIG0_SD_PU_TX_OFFSET;
1039         mask |= SD_EXTERNAL_CONFIG0_HALF_BUS_MODE_MASK;
1040         data |= 1 << SD_EXTERNAL_CONFIG0_HALF_BUS_MODE_OFFSET;
1041         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG0_REG, data, mask);
1042
1043         /* release from hard reset */
1044         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
1045         data = 0x0 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
1046         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
1047         data |= 0x0 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
1048         mask |= SD_EXTERNAL_CONFIG1_RF_RESET_IN_MASK;
1049         data |= 0x0 << SD_EXTERNAL_CONFIG1_RF_RESET_IN_OFFSET;
1050         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1051
1052         /* release from hard reset */
1053         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
1054         data = 0x1 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
1055         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
1056         data |= 0x1 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
1057         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1058
1059
1060         /* Wait 1ms - until band gap and ref clock ready */
1061         mdelay(1);
1062
1063         /* Start comphy Configuration */
1064         debug("stage: Comphy configuration\n");
1065         /* set reference clock */
1066         mask = HPIPE_MISC_REFCLK_SEL_MASK;
1067         data = 0x0 << HPIPE_MISC_REFCLK_SEL_OFFSET;
1068         reg_set(hpipe_addr + HPIPE_MISC_REG, data, mask);
1069         /* Power and PLL Control */
1070         mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
1071         data = 0x1 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
1072         mask |= HPIPE_PWR_PLL_PHY_MODE_MASK;
1073         data |= 0x4 << HPIPE_PWR_PLL_PHY_MODE_OFFSET;
1074         reg_set(hpipe_addr + HPIPE_PWR_PLL_REG, data, mask);
1075         /* Loopback register */
1076         mask = HPIPE_LOOPBACK_SEL_MASK;
1077         data = 0x1 << HPIPE_LOOPBACK_SEL_OFFSET;
1078         reg_set(hpipe_addr + HPIPE_LOOPBACK_REG, data, mask);
1079         /* rx control 1 */
1080         mask = HPIPE_RX_CONTROL_1_RXCLK2X_SEL_MASK;
1081         data = 0x1 << HPIPE_RX_CONTROL_1_RXCLK2X_SEL_OFFSET;
1082         mask |= HPIPE_RX_CONTROL_1_CLK8T_EN_MASK;
1083         data |= 0x0 << HPIPE_RX_CONTROL_1_CLK8T_EN_OFFSET;
1084         reg_set(hpipe_addr + HPIPE_RX_CONTROL_1_REG, data, mask);
1085         /* DTL Control */
1086         mask = HPIPE_PWR_CTR_DTL_FLOOP_EN_MASK;
1087         data = 0x0 << HPIPE_PWR_CTR_DTL_FLOOP_EN_OFFSET;
1088         reg_set(hpipe_addr + HPIPE_PWR_CTR_DTL_REG, data, mask);
1089
1090         /* Set analog paramters from ETP(HW) - for now use the default datas */
1091         debug("stage: Analog paramters from ETP(HW)\n");
1092
1093         reg_set(hpipe_addr + HPIPE_G1_SET_0_REG,
1094                 0x1 << HPIPE_G1_SET_0_G1_TX_EMPH1_OFFSET,
1095                 HPIPE_G1_SET_0_G1_TX_EMPH1_MASK);
1096
1097         debug("stage: RFU configurations- Power Up PLL,Tx,Rx\n");
1098         /* SERDES External Configuration */
1099         mask = SD_EXTERNAL_CONFIG0_SD_PU_PLL_MASK;
1100         data = 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_PLL_OFFSET;
1101         mask |= SD_EXTERNAL_CONFIG0_SD_PU_RX_MASK;
1102         data |= 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_RX_OFFSET;
1103         mask |= SD_EXTERNAL_CONFIG0_SD_PU_TX_MASK;
1104         data |= 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_TX_OFFSET;
1105         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG0_REG, data, mask);
1106
1107         /* check PLL rx & tx ready */
1108         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
1109         data = SD_EXTERNAL_STATUS0_PLL_RX_MASK |
1110                 SD_EXTERNAL_STATUS0_PLL_TX_MASK;
1111         mask = data;
1112         data = polling_with_timeout(addr, data, mask, 15000);
1113         if (data != 0) {
1114                 debug("Read from reg = %p - value = 0x%x\n",
1115                       sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
1116                 pr_err("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
1117                       (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK),
1118                       (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK));
1119                 ret = 0;
1120         }
1121
1122         /* RX init */
1123         mask = SD_EXTERNAL_CONFIG1_RX_INIT_MASK;
1124         data = 0x1 << SD_EXTERNAL_CONFIG1_RX_INIT_OFFSET;
1125         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1126
1127         /* check that RX init done */
1128         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
1129         data = SD_EXTERNAL_STATUS0_RX_INIT_MASK;
1130         mask = data;
1131         data = polling_with_timeout(addr, data, mask, 100);
1132         if (data != 0) {
1133                 debug("Read from reg = %p - value = 0x%x\n", sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
1134                 pr_err("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
1135                 ret = 0;
1136         }
1137
1138         debug("stage: RF Reset\n");
1139         /* RF Reset */
1140         mask =  SD_EXTERNAL_CONFIG1_RX_INIT_MASK;
1141         data = 0x0 << SD_EXTERNAL_CONFIG1_RX_INIT_OFFSET;
1142         mask |= SD_EXTERNAL_CONFIG1_RF_RESET_IN_MASK;
1143         data |= 0x1 << SD_EXTERNAL_CONFIG1_RF_RESET_IN_OFFSET;
1144         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1145
1146         debug_exit();
1147         return ret;
1148 }
1149
1150 static int comphy_sfi_power_up(u32 lane, void __iomem *hpipe_base,
1151                                void __iomem *comphy_base, u32 speed)
1152 {
1153         u32 mask, data, ret = 1;
1154         void __iomem *hpipe_addr = HPIPE_ADDR(hpipe_base, lane);
1155         void __iomem *sd_ip_addr = SD_ADDR(hpipe_base, lane);
1156         void __iomem *comphy_addr = COMPHY_ADDR(comphy_base, lane);
1157         void __iomem *addr;
1158
1159         debug_enter();
1160         debug("stage: RFU configurations - hard reset comphy\n");
1161         /* RFU configurations - hard reset comphy */
1162         mask = COMMON_PHY_CFG1_PWR_UP_MASK;
1163         data = 0x1 << COMMON_PHY_CFG1_PWR_UP_OFFSET;
1164         mask |= COMMON_PHY_CFG1_PIPE_SELECT_MASK;
1165         data |= 0x0 << COMMON_PHY_CFG1_PIPE_SELECT_OFFSET;
1166         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
1167
1168         /* Select Baud Rate of Comphy And PD_PLL/Tx/Rx */
1169         mask = SD_EXTERNAL_CONFIG0_SD_PU_PLL_MASK;
1170         data = 0x0 << SD_EXTERNAL_CONFIG0_SD_PU_PLL_OFFSET;
1171         mask |= SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_MASK;
1172         data |= 0xE << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_OFFSET;
1173         mask |= SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_MASK;
1174         data |= 0xE << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_OFFSET;
1175         mask |= SD_EXTERNAL_CONFIG0_SD_PU_RX_MASK;
1176         data |= 0 << SD_EXTERNAL_CONFIG0_SD_PU_RX_OFFSET;
1177         mask |= SD_EXTERNAL_CONFIG0_SD_PU_TX_MASK;
1178         data |= 0 << SD_EXTERNAL_CONFIG0_SD_PU_TX_OFFSET;
1179         mask |= SD_EXTERNAL_CONFIG0_HALF_BUS_MODE_MASK;
1180         data |= 0 << SD_EXTERNAL_CONFIG0_HALF_BUS_MODE_OFFSET;
1181         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG0_REG, data, mask);
1182
1183         /* release from hard reset */
1184         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
1185         data = 0x0 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
1186         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
1187         data |= 0x0 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
1188         mask |= SD_EXTERNAL_CONFIG1_RF_RESET_IN_MASK;
1189         data |= 0x0 << SD_EXTERNAL_CONFIG1_RF_RESET_IN_OFFSET;
1190         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1191
1192         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
1193         data = 0x1 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
1194         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
1195         data |= 0x1 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
1196         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1197
1198
1199         /* Wait 1ms - until band gap and ref clock ready */
1200         mdelay(1);
1201
1202         /* Start comphy Configuration */
1203         debug("stage: Comphy configuration\n");
1204         /* set reference clock */
1205         mask = HPIPE_MISC_ICP_FORCE_MASK;
1206         data = (speed == PHY_SPEED_5_15625G) ?
1207                 (0x0 << HPIPE_MISC_ICP_FORCE_OFFSET) :
1208                 (0x1 << HPIPE_MISC_ICP_FORCE_OFFSET);
1209         mask |= HPIPE_MISC_REFCLK_SEL_MASK;
1210         data |= 0x0 << HPIPE_MISC_REFCLK_SEL_OFFSET;
1211         reg_set(hpipe_addr + HPIPE_MISC_REG, data, mask);
1212         /* Power and PLL Control */
1213         mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
1214         data = 0x1 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
1215         mask |= HPIPE_PWR_PLL_PHY_MODE_MASK;
1216         data |= 0x4 << HPIPE_PWR_PLL_PHY_MODE_OFFSET;
1217         reg_set(hpipe_addr + HPIPE_PWR_PLL_REG, data, mask);
1218         /* Loopback register */
1219         mask = HPIPE_LOOPBACK_SEL_MASK;
1220         data = 0x1 << HPIPE_LOOPBACK_SEL_OFFSET;
1221         reg_set(hpipe_addr + HPIPE_LOOPBACK_REG, data, mask);
1222         /* rx control 1 */
1223         mask = HPIPE_RX_CONTROL_1_RXCLK2X_SEL_MASK;
1224         data = 0x1 << HPIPE_RX_CONTROL_1_RXCLK2X_SEL_OFFSET;
1225         mask |= HPIPE_RX_CONTROL_1_CLK8T_EN_MASK;
1226         data |= 0x1 << HPIPE_RX_CONTROL_1_CLK8T_EN_OFFSET;
1227         reg_set(hpipe_addr + HPIPE_RX_CONTROL_1_REG, data, mask);
1228         /* DTL Control */
1229         mask = HPIPE_PWR_CTR_DTL_FLOOP_EN_MASK;
1230         data = 0x1 << HPIPE_PWR_CTR_DTL_FLOOP_EN_OFFSET;
1231         reg_set(hpipe_addr + HPIPE_PWR_CTR_DTL_REG, data, mask);
1232
1233         /* Transmitter/Receiver Speed Divider Force */
1234         if (speed == PHY_SPEED_5_15625G) {
1235                 mask = HPIPE_SPD_DIV_FORCE_RX_SPD_DIV_MASK;
1236                 data = 1 << HPIPE_SPD_DIV_FORCE_RX_SPD_DIV_OFFSET;
1237                 mask |= HPIPE_SPD_DIV_FORCE_RX_SPD_DIV_FORCE_MASK;
1238                 data |= 1 << HPIPE_SPD_DIV_FORCE_RX_SPD_DIV_FORCE_OFFSET;
1239                 mask |= HPIPE_SPD_DIV_FORCE_TX_SPD_DIV_MASK;
1240                 data |= 1 << HPIPE_SPD_DIV_FORCE_TX_SPD_DIV_OFFSET;
1241                 mask |= HPIPE_SPD_DIV_FORCE_TX_SPD_DIV_FORCE_MASK;
1242                 data |= 1 << HPIPE_SPD_DIV_FORCE_TX_SPD_DIV_FORCE_OFFSET;
1243         } else {
1244                 mask = HPIPE_TXDIGCK_DIV_FORCE_MASK;
1245                 data = 0x1 << HPIPE_TXDIGCK_DIV_FORCE_OFFSET;
1246         }
1247         reg_set(hpipe_addr + HPIPE_SPD_DIV_FORCE_REG, data, mask);
1248
1249         /* Set analog paramters from ETP(HW) */
1250         debug("stage: Analog paramters from ETP(HW)\n");
1251         /* SERDES External Configuration 2 */
1252         mask = SD_EXTERNAL_CONFIG2_PIN_DFE_EN_MASK;
1253         data = 0x1 << SD_EXTERNAL_CONFIG2_PIN_DFE_EN_OFFSET;
1254         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG2_REG, data, mask);
1255         /* 0x7-DFE Resolution control */
1256         mask = HPIPE_DFE_RES_FORCE_MASK;
1257         data = 0x1 << HPIPE_DFE_RES_FORCE_OFFSET;
1258         reg_set(hpipe_addr + HPIPE_DFE_REG0, data, mask);
1259         /* 0xd-G1_Setting_0 */
1260         if (speed == PHY_SPEED_5_15625G) {
1261                 mask = HPIPE_G1_SET_0_G1_TX_EMPH1_MASK;
1262                 data = 0x6 << HPIPE_G1_SET_0_G1_TX_EMPH1_OFFSET;
1263         } else {
1264                 mask = HPIPE_G1_SET_0_G1_TX_AMP_MASK;
1265                 data = 0x1c << HPIPE_G1_SET_0_G1_TX_AMP_OFFSET;
1266                 mask |= HPIPE_G1_SET_0_G1_TX_EMPH1_MASK;
1267                 data |= 0xe << HPIPE_G1_SET_0_G1_TX_EMPH1_OFFSET;
1268         }
1269         reg_set(hpipe_addr + HPIPE_G1_SET_0_REG, data, mask);
1270         /* Genration 1 setting 2 (G1_Setting_2) */
1271         mask = HPIPE_G1_SET_2_G1_TX_EMPH0_MASK;
1272         data = 0x0 << HPIPE_G1_SET_2_G1_TX_EMPH0_OFFSET;
1273         mask |= HPIPE_G1_SET_2_G1_TX_EMPH0_EN_MASK;
1274         data |= 0x1 << HPIPE_G1_SET_2_G1_TX_EMPH0_EN_OFFSET;
1275         reg_set(hpipe_addr + HPIPE_G1_SET_2_REG, data, mask);
1276         /* Transmitter Slew Rate Control register (tx_reg1) */
1277         mask = HPIPE_TX_REG1_TX_EMPH_RES_MASK;
1278         data = 0x3 << HPIPE_TX_REG1_TX_EMPH_RES_OFFSET;
1279         mask |= HPIPE_TX_REG1_SLC_EN_MASK;
1280         data |= 0x3f << HPIPE_TX_REG1_SLC_EN_OFFSET;
1281         reg_set(hpipe_addr + HPIPE_TX_REG1_REG, data, mask);
1282         /* Impedance Calibration Control register (cal_reg1) */
1283         mask = HPIPE_CAL_REG_1_EXT_TXIMP_MASK;
1284         data = 0xe << HPIPE_CAL_REG_1_EXT_TXIMP_OFFSET;
1285         mask |= HPIPE_CAL_REG_1_EXT_TXIMP_EN_MASK;
1286         data |= 0x1 << HPIPE_CAL_REG_1_EXT_TXIMP_EN_OFFSET;
1287         reg_set(hpipe_addr + HPIPE_CAL_REG1_REG, data, mask);
1288         /* Generation 1 Setting 5 (g1_setting_5) */
1289         mask = HPIPE_G1_SETTING_5_G1_ICP_MASK;
1290         data = 0 << HPIPE_CAL_REG_1_EXT_TXIMP_OFFSET;
1291         reg_set(hpipe_addr + HPIPE_G1_SETTING_5_REG, data, mask);
1292         /* 0xE-G1_Setting_1 */
1293         mask = HPIPE_G1_SET_1_G1_RX_DFE_EN_MASK;
1294         data = 0x1 << HPIPE_G1_SET_1_G1_RX_DFE_EN_OFFSET;
1295         if (speed == PHY_SPEED_5_15625G) {
1296                 mask |= HPIPE_G1_SET_1_G1_RX_SELMUPI_MASK;
1297                 data |= 0x1 << HPIPE_G1_SET_1_G1_RX_SELMUPI_OFFSET;
1298                 mask |= HPIPE_G1_SET_1_G1_RX_SELMUPP_MASK;
1299                 data |= 0x1 << HPIPE_G1_SET_1_G1_RX_SELMUPP_OFFSET;
1300         } else {
1301                 mask |= HPIPE_G1_SET_1_G1_RX_SELMUPI_MASK;
1302                 data |= 0x2 << HPIPE_G1_SET_1_G1_RX_SELMUPI_OFFSET;
1303                 mask |= HPIPE_G1_SET_1_G1_RX_SELMUPP_MASK;
1304                 data |= 0x2 << HPIPE_G1_SET_1_G1_RX_SELMUPP_OFFSET;
1305                 mask |= HPIPE_G1_SET_1_G1_RX_SELMUFI_MASK;
1306                 data |= 0x0 << HPIPE_G1_SET_1_G1_RX_SELMUFI_OFFSET;
1307                 mask |= HPIPE_G1_SET_1_G1_RX_SELMUFF_MASK;
1308                 data |= 0x1 << HPIPE_G1_SET_1_G1_RX_SELMUFF_OFFSET;
1309                 mask |= HPIPE_G1_SET_1_G1_RX_DIGCK_DIV_MASK;
1310                 data |= 0x3 << HPIPE_G1_SET_1_G1_RX_DIGCK_DIV_OFFSET;
1311         }
1312         reg_set(hpipe_addr + HPIPE_G1_SET_1_REG, data, mask);
1313
1314         /* 0xA-DFE_Reg3 */
1315         mask = HPIPE_DFE_F3_F5_DFE_EN_MASK;
1316         data = 0x0 << HPIPE_DFE_F3_F5_DFE_EN_OFFSET;
1317         mask |= HPIPE_DFE_F3_F5_DFE_CTRL_MASK;
1318         data |= 0x0 << HPIPE_DFE_F3_F5_DFE_CTRL_OFFSET;
1319         reg_set(hpipe_addr + HPIPE_DFE_F3_F5_REG, data, mask);
1320
1321         /* 0x111-G1_Setting_4 */
1322         mask = HPIPE_G1_SETTINGS_4_G1_DFE_RES_MASK;
1323         data = 0x1 << HPIPE_G1_SETTINGS_4_G1_DFE_RES_OFFSET;
1324         reg_set(hpipe_addr + HPIPE_G1_SETTINGS_4_REG, data, mask);
1325         /* Genration 1 setting 3 (G1_Setting_3) */
1326         mask = HPIPE_G1_SETTINGS_3_G1_FBCK_SEL_MASK;
1327         data = 0x1 << HPIPE_G1_SETTINGS_3_G1_FBCK_SEL_OFFSET;
1328         if (speed == PHY_SPEED_5_15625G) {
1329                 /* Force FFE (Feed Forward Equalization) to 5G */
1330                 mask |= HPIPE_G1_SETTINGS_3_G1_FFE_CAP_SEL_MASK;
1331                 data |= 0xf << HPIPE_G1_SETTINGS_3_G1_FFE_CAP_SEL_OFFSET;
1332                 mask |= HPIPE_G1_SETTINGS_3_G1_FFE_RES_SEL_MASK;
1333                 data |= 0x4 << HPIPE_G1_SETTINGS_3_G1_FFE_RES_SEL_OFFSET;
1334                 mask |= HPIPE_G1_SETTINGS_3_G1_FFE_SETTING_FORCE_MASK;
1335                 data |= 0x1 << HPIPE_G1_SETTINGS_3_G1_FFE_SETTING_FORCE_OFFSET;
1336         }
1337         reg_set(hpipe_addr + HPIPE_G1_SETTINGS_3_REG, data, mask);
1338
1339         /* Connfigure RX training timer */
1340         mask = HPIPE_RX_TRAIN_TIMER_MASK;
1341         data = 0x13 << HPIPE_RX_TRAIN_TIMER_OFFSET;
1342         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_5_REG, data, mask);
1343
1344         /* Enable TX train peak to peak hold */
1345         mask = HPIPE_TX_TRAIN_P2P_HOLD_MASK;
1346         data = 0x1 << HPIPE_TX_TRAIN_P2P_HOLD_OFFSET;
1347         reg_set(hpipe_addr + HPIPE_TX_TRAIN_CTRL_0_REG, data, mask);
1348
1349         /* Configure TX preset index */
1350         mask = HPIPE_TX_PRESET_INDEX_MASK;
1351         data = 0x2 << HPIPE_TX_PRESET_INDEX_OFFSET;
1352         reg_set(hpipe_addr + HPIPE_TX_PRESET_INDEX_REG, data, mask);
1353
1354         /* Disable pattern lock lost timeout */
1355         mask = HPIPE_PATTERN_LOCK_LOST_TIMEOUT_EN_MASK;
1356         data = 0x0 << HPIPE_PATTERN_LOCK_LOST_TIMEOUT_EN_OFFSET;
1357         reg_set(hpipe_addr + HPIPE_FRAME_DETECT_CTRL_3_REG, data, mask);
1358
1359         /* Configure TX training pattern and TX training 16bit auto */
1360         mask = HPIPE_TX_TRAIN_16BIT_AUTO_EN_MASK;
1361         data = 0x1 << HPIPE_TX_TRAIN_16BIT_AUTO_EN_OFFSET;
1362         mask |= HPIPE_TX_TRAIN_PAT_SEL_MASK;
1363         data |= 0x1 << HPIPE_TX_TRAIN_PAT_SEL_OFFSET;
1364         reg_set(hpipe_addr + HPIPE_TX_TRAIN_REG, data, mask);
1365
1366         /* Configure Training patten number */
1367         mask = HPIPE_TRAIN_PAT_NUM_MASK;
1368         data = 0x88 << HPIPE_TRAIN_PAT_NUM_OFFSET;
1369         reg_set(hpipe_addr + HPIPE_FRAME_DETECT_CTRL_0_REG, data, mask);
1370
1371         /* Configure differencial manchester encoter to ethernet mode */
1372         mask = HPIPE_DME_ETHERNET_MODE_MASK;
1373         data = 0x1 << HPIPE_DME_ETHERNET_MODE_OFFSET;
1374         reg_set(hpipe_addr + HPIPE_DME_REG, data, mask);
1375
1376         /* Configure VDD Continuous Calibration */
1377         mask = HPIPE_CAL_VDD_CONT_MODE_MASK;
1378         data = 0x1 << HPIPE_CAL_VDD_CONT_MODE_OFFSET;
1379         reg_set(hpipe_addr + HPIPE_VDD_CAL_0_REG, data, mask);
1380
1381         /* Trigger sampler enable pulse (by toggleing the bit) */
1382         mask = HPIPE_RX_SAMPLER_OS_GAIN_MASK;
1383         data = 0x3 << HPIPE_RX_SAMPLER_OS_GAIN_OFFSET;
1384         mask |= HPIPE_SMAPLER_MASK;
1385         data |= 0x1 << HPIPE_SMAPLER_OFFSET;
1386         reg_set(hpipe_addr + HPIPE_SAMPLER_N_PROC_CALIB_CTRL_REG, data, mask);
1387         mask = HPIPE_SMAPLER_MASK;
1388         data = 0x0 << HPIPE_SMAPLER_OFFSET;
1389         reg_set(hpipe_addr + HPIPE_SAMPLER_N_PROC_CALIB_CTRL_REG, data, mask);
1390
1391         /* Set External RX Regulator Control */
1392         mask = HPIPE_EXT_SELLV_RXSAMPL_MASK;
1393         data = 0x1A << HPIPE_EXT_SELLV_RXSAMPL_OFFSET;
1394         reg_set(hpipe_addr + HPIPE_VDD_CAL_CTRL_REG, data, mask);
1395
1396         debug("stage: RFU configurations- Power Up PLL,Tx,Rx\n");
1397         /* SERDES External Configuration */
1398         mask = SD_EXTERNAL_CONFIG0_SD_PU_PLL_MASK;
1399         data = 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_PLL_OFFSET;
1400         mask |= SD_EXTERNAL_CONFIG0_SD_PU_RX_MASK;
1401         data |= 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_RX_OFFSET;
1402         mask |= SD_EXTERNAL_CONFIG0_SD_PU_TX_MASK;
1403         data |= 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_TX_OFFSET;
1404         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG0_REG, data, mask);
1405
1406
1407         /* check PLL rx & tx ready */
1408         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
1409         data = SD_EXTERNAL_STATUS0_PLL_RX_MASK |
1410                 SD_EXTERNAL_STATUS0_PLL_TX_MASK;
1411         mask = data;
1412         data = polling_with_timeout(addr, data, mask, 15000);
1413         if (data != 0) {
1414                 debug("Read from reg = %p - value = 0x%x\n", sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
1415                 pr_err("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
1416                       (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK),
1417                       (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK));
1418                 ret = 0;
1419         }
1420
1421         /* RX init */
1422         mask = SD_EXTERNAL_CONFIG1_RX_INIT_MASK;
1423         data = 0x1 << SD_EXTERNAL_CONFIG1_RX_INIT_OFFSET;
1424         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1425
1426
1427         /* check that RX init done */
1428         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
1429         data = SD_EXTERNAL_STATUS0_RX_INIT_MASK;
1430         mask = data;
1431         data = polling_with_timeout(addr, data, mask, 100);
1432         if (data != 0) {
1433                 debug("Read from reg = %p - value = 0x%x\n",
1434                       sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
1435                 pr_err("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
1436                 ret = 0;
1437         }
1438
1439         debug("stage: RF Reset\n");
1440         /* RF Reset */
1441         mask =  SD_EXTERNAL_CONFIG1_RX_INIT_MASK;
1442         data = 0x0 << SD_EXTERNAL_CONFIG1_RX_INIT_OFFSET;
1443         mask |= SD_EXTERNAL_CONFIG1_RF_RESET_IN_MASK;
1444         data |= 0x1 << SD_EXTERNAL_CONFIG1_RF_RESET_IN_OFFSET;
1445         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1446
1447         debug_exit();
1448         return ret;
1449 }
1450
1451 static int comphy_rxauii_power_up(u32 lane, void __iomem *hpipe_base,
1452                                   void __iomem *comphy_base)
1453 {
1454         u32 mask, data, ret = 1;
1455         void __iomem *hpipe_addr = HPIPE_ADDR(hpipe_base, lane);
1456         void __iomem *sd_ip_addr = SD_ADDR(hpipe_base, lane);
1457         void __iomem *comphy_addr = COMPHY_ADDR(comphy_base, lane);
1458         void __iomem *addr;
1459
1460         debug_enter();
1461         debug("stage: RFU configurations - hard reset comphy\n");
1462         /* RFU configurations - hard reset comphy */
1463         mask = COMMON_PHY_CFG1_PWR_UP_MASK;
1464         data = 0x1 << COMMON_PHY_CFG1_PWR_UP_OFFSET;
1465         mask |= COMMON_PHY_CFG1_PIPE_SELECT_MASK;
1466         data |= 0x0 << COMMON_PHY_CFG1_PIPE_SELECT_OFFSET;
1467         reg_set(comphy_addr + COMMON_PHY_CFG1_REG, data, mask);
1468
1469         if (lane == 2) {
1470                 reg_set(comphy_base + COMMON_PHY_SD_CTRL1,
1471                         0x1 << COMMON_PHY_SD_CTRL1_RXAUI0_OFFSET,
1472                         COMMON_PHY_SD_CTRL1_RXAUI0_MASK);
1473         }
1474         if (lane == 4) {
1475                 reg_set(comphy_base + COMMON_PHY_SD_CTRL1,
1476                         0x1 << COMMON_PHY_SD_CTRL1_RXAUI1_OFFSET,
1477                         COMMON_PHY_SD_CTRL1_RXAUI1_MASK);
1478         }
1479
1480         /* Select Baud Rate of Comphy And PD_PLL/Tx/Rx */
1481         mask = SD_EXTERNAL_CONFIG0_SD_PU_PLL_MASK;
1482         data = 0x0 << SD_EXTERNAL_CONFIG0_SD_PU_PLL_OFFSET;
1483         mask |= SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_MASK;
1484         data |= 0xB << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_RX_OFFSET;
1485         mask |= SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_MASK;
1486         data |= 0xB << SD_EXTERNAL_CONFIG0_SD_PHY_GEN_TX_OFFSET;
1487         mask |= SD_EXTERNAL_CONFIG0_SD_PU_RX_MASK;
1488         data |= 0x0 << SD_EXTERNAL_CONFIG0_SD_PU_RX_OFFSET;
1489         mask |= SD_EXTERNAL_CONFIG0_SD_PU_TX_MASK;
1490         data |= 0x0 << SD_EXTERNAL_CONFIG0_SD_PU_TX_OFFSET;
1491         mask |= SD_EXTERNAL_CONFIG0_HALF_BUS_MODE_MASK;
1492         data |= 0x0 << SD_EXTERNAL_CONFIG0_HALF_BUS_MODE_OFFSET;
1493         mask |= SD_EXTERNAL_CONFIG0_MEDIA_MODE_MASK;
1494         data |= 0x1 << SD_EXTERNAL_CONFIG0_MEDIA_MODE_OFFSET;
1495         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG0_REG, data, mask);
1496
1497         /* release from hard reset */
1498         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
1499         data = 0x0 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
1500         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
1501         data |= 0x0 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
1502         mask |= SD_EXTERNAL_CONFIG1_RF_RESET_IN_MASK;
1503         data |= 0x0 << SD_EXTERNAL_CONFIG1_RF_RESET_IN_OFFSET;
1504         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1505
1506         mask = SD_EXTERNAL_CONFIG1_RESET_IN_MASK;
1507         data = 0x1 << SD_EXTERNAL_CONFIG1_RESET_IN_OFFSET;
1508         mask |= SD_EXTERNAL_CONFIG1_RESET_CORE_MASK;
1509         data |= 0x1 << SD_EXTERNAL_CONFIG1_RESET_CORE_OFFSET;
1510         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1511
1512         /* Wait 1ms - until band gap and ref clock ready */
1513         mdelay(1);
1514
1515         /* Start comphy Configuration */
1516         debug("stage: Comphy configuration\n");
1517         /* set reference clock */
1518         reg_set(hpipe_addr + HPIPE_MISC_REG,
1519                 0x0 << HPIPE_MISC_REFCLK_SEL_OFFSET,
1520                 HPIPE_MISC_REFCLK_SEL_MASK);
1521         /* Power and PLL Control */
1522         mask = HPIPE_PWR_PLL_REF_FREQ_MASK;
1523         data = 0x1 << HPIPE_PWR_PLL_REF_FREQ_OFFSET;
1524         mask |= HPIPE_PWR_PLL_PHY_MODE_MASK;
1525         data |= 0x4 << HPIPE_PWR_PLL_PHY_MODE_OFFSET;
1526         reg_set(hpipe_addr + HPIPE_PWR_PLL_REG, data, mask);
1527         /* Loopback register */
1528         reg_set(hpipe_addr + HPIPE_LOOPBACK_REG,
1529                 0x1 << HPIPE_LOOPBACK_SEL_OFFSET, HPIPE_LOOPBACK_SEL_MASK);
1530         /* rx control 1 */
1531         mask = HPIPE_RX_CONTROL_1_RXCLK2X_SEL_MASK;
1532         data = 0x1 << HPIPE_RX_CONTROL_1_RXCLK2X_SEL_OFFSET;
1533         mask |= HPIPE_RX_CONTROL_1_CLK8T_EN_MASK;
1534         data |= 0x1 << HPIPE_RX_CONTROL_1_CLK8T_EN_OFFSET;
1535         reg_set(hpipe_addr + HPIPE_RX_CONTROL_1_REG, data, mask);
1536         /* DTL Control */
1537         reg_set(hpipe_addr + HPIPE_PWR_CTR_DTL_REG,
1538                 0x0 << HPIPE_PWR_CTR_DTL_FLOOP_EN_OFFSET,
1539                 HPIPE_PWR_CTR_DTL_FLOOP_EN_MASK);
1540
1541         /* Set analog paramters from ETP(HW) */
1542         debug("stage: Analog paramters from ETP(HW)\n");
1543         /* SERDES External Configuration 2 */
1544         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG2_REG,
1545                 0x1 << SD_EXTERNAL_CONFIG2_PIN_DFE_EN_OFFSET,
1546                 SD_EXTERNAL_CONFIG2_PIN_DFE_EN_MASK);
1547         /* 0x7-DFE Resolution control */
1548         reg_set(hpipe_addr + HPIPE_DFE_REG0, 0x1 << HPIPE_DFE_RES_FORCE_OFFSET,
1549                 HPIPE_DFE_RES_FORCE_MASK);
1550         /* 0xd-G1_Setting_0 */
1551         reg_set(hpipe_addr + HPIPE_G1_SET_0_REG,
1552                 0xd << HPIPE_G1_SET_0_G1_TX_EMPH1_OFFSET,
1553                 HPIPE_G1_SET_0_G1_TX_EMPH1_MASK);
1554         /* 0xE-G1_Setting_1 */
1555         mask = HPIPE_G1_SET_1_G1_RX_SELMUPI_MASK;
1556         data = 0x1 << HPIPE_G1_SET_1_G1_RX_SELMUPI_OFFSET;
1557         mask |= HPIPE_G1_SET_1_G1_RX_SELMUPP_MASK;
1558         data |= 0x1 << HPIPE_G1_SET_1_G1_RX_SELMUPP_OFFSET;
1559         mask |= HPIPE_G1_SET_1_G1_RX_DFE_EN_MASK;
1560         data |= 0x1 << HPIPE_G1_SET_1_G1_RX_DFE_EN_OFFSET;
1561         reg_set(hpipe_addr + HPIPE_G1_SET_1_REG, data, mask);
1562         /* 0xA-DFE_Reg3 */
1563         mask = HPIPE_DFE_F3_F5_DFE_EN_MASK;
1564         data = 0x0 << HPIPE_DFE_F3_F5_DFE_EN_OFFSET;
1565         mask |= HPIPE_DFE_F3_F5_DFE_CTRL_MASK;
1566         data |= 0x0 << HPIPE_DFE_F3_F5_DFE_CTRL_OFFSET;
1567         reg_set(hpipe_addr + HPIPE_DFE_F3_F5_REG, data, mask);
1568
1569         /* 0x111-G1_Setting_4 */
1570         mask = HPIPE_G1_SETTINGS_4_G1_DFE_RES_MASK;
1571         data = 0x1 << HPIPE_G1_SETTINGS_4_G1_DFE_RES_OFFSET;
1572         reg_set(hpipe_addr + HPIPE_G1_SETTINGS_4_REG, data, mask);
1573
1574         debug("stage: RFU configurations- Power Up PLL,Tx,Rx\n");
1575         /* SERDES External Configuration */
1576         mask = SD_EXTERNAL_CONFIG0_SD_PU_PLL_MASK;
1577         data = 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_PLL_OFFSET;
1578         mask |= SD_EXTERNAL_CONFIG0_SD_PU_RX_MASK;
1579         data |= 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_RX_OFFSET;
1580         mask |= SD_EXTERNAL_CONFIG0_SD_PU_TX_MASK;
1581         data |= 0x1 << SD_EXTERNAL_CONFIG0_SD_PU_TX_OFFSET;
1582         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG0_REG, data, mask);
1583
1584
1585         /* check PLL rx & tx ready */
1586         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
1587         data = SD_EXTERNAL_STATUS0_PLL_RX_MASK |
1588                 SD_EXTERNAL_STATUS0_PLL_TX_MASK;
1589         mask = data;
1590         data = polling_with_timeout(addr, data, mask, 15000);
1591         if (data != 0) {
1592                 debug("Read from reg = %p - value = 0x%x\n",
1593                       sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
1594                 pr_err("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
1595                       (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK),
1596                       (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK));
1597                 ret = 0;
1598         }
1599
1600         /* RX init */
1601         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG,
1602                 0x1 << SD_EXTERNAL_CONFIG1_RX_INIT_OFFSET,
1603                 SD_EXTERNAL_CONFIG1_RX_INIT_MASK);
1604
1605         /* check that RX init done */
1606         addr = sd_ip_addr + SD_EXTERNAL_STATUS0_REG;
1607         data = SD_EXTERNAL_STATUS0_RX_INIT_MASK;
1608         mask = data;
1609         data = polling_with_timeout(addr, data, mask, 100);
1610         if (data != 0) {
1611                 debug("Read from reg = %p - value = 0x%x\n",
1612                       sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
1613                 pr_err("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
1614                 ret = 0;
1615         }
1616
1617         debug("stage: RF Reset\n");
1618         /* RF Reset */
1619         mask =  SD_EXTERNAL_CONFIG1_RX_INIT_MASK;
1620         data = 0x0 << SD_EXTERNAL_CONFIG1_RX_INIT_OFFSET;
1621         mask |= SD_EXTERNAL_CONFIG1_RF_RESET_IN_MASK;
1622         data |= 0x1 << SD_EXTERNAL_CONFIG1_RF_RESET_IN_OFFSET;
1623         reg_set(sd_ip_addr + SD_EXTERNAL_CONFIG1_REG, data, mask);
1624
1625         debug_exit();
1626         return ret;
1627 }
1628
1629 static void comphy_utmi_power_down(u32 utmi_index, void __iomem *utmi_base_addr,
1630                                    void __iomem *usb_cfg_addr,
1631                                    void __iomem *utmi_cfg_addr,
1632                                    u32 utmi_phy_port)
1633 {
1634         u32 mask, data;
1635
1636         debug_enter();
1637         debug("stage:  UTMI %d - Power down transceiver (power down Phy), Power down PLL, and SuspendDM\n",
1638               utmi_index);
1639         /* Power down UTMI PHY */
1640         reg_set(utmi_cfg_addr, 0x0 << UTMI_PHY_CFG_PU_OFFSET,
1641                 UTMI_PHY_CFG_PU_MASK);
1642
1643         /*
1644          * If UTMI connected to USB Device, configure mux prior to PHY init
1645          * (Device can be connected to UTMI0 or to UTMI1)
1646          */
1647         if (utmi_phy_port == UTMI_PHY_TO_USB3_DEVICE0) {
1648                 debug("stage:  UTMI %d - Enable Device mode and configure UTMI mux\n",
1649                       utmi_index);
1650                 /* USB3 Device UTMI enable */
1651                 mask = UTMI_USB_CFG_DEVICE_EN_MASK;
1652                 data = 0x1 << UTMI_USB_CFG_DEVICE_EN_OFFSET;
1653                 /* USB3 Device UTMI MUX */
1654                 mask |= UTMI_USB_CFG_DEVICE_MUX_MASK;
1655                 data |= utmi_index << UTMI_USB_CFG_DEVICE_MUX_OFFSET;
1656                 reg_set(usb_cfg_addr,  data, mask);
1657         }
1658
1659         /* Set Test suspendm mode */
1660         mask = UTMI_CTRL_STATUS0_SUSPENDM_MASK;
1661         data = 0x1 << UTMI_CTRL_STATUS0_SUSPENDM_OFFSET;
1662         /* Enable Test UTMI select */
1663         mask |= UTMI_CTRL_STATUS0_TEST_SEL_MASK;
1664         data |= 0x1 << UTMI_CTRL_STATUS0_TEST_SEL_OFFSET;
1665         reg_set(utmi_base_addr + UTMI_CTRL_STATUS0_REG, data, mask);
1666
1667         /* Wait for UTMI power down */
1668         mdelay(1);
1669
1670         debug_exit();
1671         return;
1672 }
1673
1674 static void comphy_utmi_phy_config(u32 utmi_index, void __iomem *utmi_base_addr,
1675                                    void __iomem *usb_cfg_addr,
1676                                    void __iomem *utmi_cfg_addr,
1677                                    u32 utmi_phy_port)
1678 {
1679         u32 mask, data;
1680
1681         debug_exit();
1682         debug("stage: Configure UTMI PHY %d registers\n", utmi_index);
1683         /* Reference Clock Divider Select */
1684         mask = UTMI_PLL_CTRL_REFDIV_MASK;
1685         data = 0x5 << UTMI_PLL_CTRL_REFDIV_OFFSET;
1686         /* Feedback Clock Divider Select - 90 for 25Mhz*/
1687         mask |= UTMI_PLL_CTRL_FBDIV_MASK;
1688         data |= 0x60 << UTMI_PLL_CTRL_FBDIV_OFFSET;
1689         /* Select LPFR - 0x0 for 25Mhz/5=5Mhz*/
1690         mask |= UTMI_PLL_CTRL_SEL_LPFR_MASK;
1691         data |= 0x0 << UTMI_PLL_CTRL_SEL_LPFR_OFFSET;
1692         reg_set(utmi_base_addr + UTMI_PLL_CTRL_REG, data, mask);
1693
1694         /* Impedance Calibration Threshold Setting */
1695         reg_set(utmi_base_addr + UTMI_CALIB_CTRL_REG,
1696                 0x6 << UTMI_CALIB_CTRL_IMPCAL_VTH_OFFSET,
1697                 UTMI_CALIB_CTRL_IMPCAL_VTH_MASK);
1698
1699         /* Set LS TX driver strength coarse control */
1700         mask = UTMI_TX_CH_CTRL_DRV_EN_LS_MASK;
1701         data = 0x3 << UTMI_TX_CH_CTRL_DRV_EN_LS_OFFSET;
1702         /* Set LS TX driver fine adjustment */
1703         mask |= UTMI_TX_CH_CTRL_IMP_SEL_LS_MASK;
1704         data |= 0x3 << UTMI_TX_CH_CTRL_IMP_SEL_LS_OFFSET;
1705         reg_set(utmi_base_addr + UTMI_TX_CH_CTRL_REG, data, mask);
1706
1707         /* Enable SQ */
1708         mask = UTMI_RX_CH_CTRL0_SQ_DET_MASK;
1709         data = 0x0 << UTMI_RX_CH_CTRL0_SQ_DET_OFFSET;
1710         /* Enable analog squelch detect */
1711         mask |= UTMI_RX_CH_CTRL0_SQ_ANA_DTC_MASK;
1712         data |= 0x1 << UTMI_RX_CH_CTRL0_SQ_ANA_DTC_OFFSET;
1713         reg_set(utmi_base_addr + UTMI_RX_CH_CTRL0_REG, data, mask);
1714
1715         /* Set External squelch calibration number */
1716         mask = UTMI_RX_CH_CTRL1_SQ_AMP_CAL_MASK;
1717         data = 0x1 << UTMI_RX_CH_CTRL1_SQ_AMP_CAL_OFFSET;
1718         /* Enable the External squelch calibration */
1719         mask |= UTMI_RX_CH_CTRL1_SQ_AMP_CAL_EN_MASK;
1720         data |= 0x1 << UTMI_RX_CH_CTRL1_SQ_AMP_CAL_EN_OFFSET;
1721         reg_set(utmi_base_addr + UTMI_RX_CH_CTRL1_REG, data, mask);
1722
1723         /* Set Control VDAT Reference Voltage - 0.325V */
1724         mask = UTMI_CHGDTC_CTRL_VDAT_MASK;
1725         data = 0x1 << UTMI_CHGDTC_CTRL_VDAT_OFFSET;
1726         /* Set Control VSRC Reference Voltage - 0.6V */
1727         mask |= UTMI_CHGDTC_CTRL_VSRC_MASK;
1728         data |= 0x1 << UTMI_CHGDTC_CTRL_VSRC_OFFSET;
1729         reg_set(utmi_base_addr + UTMI_CHGDTC_CTRL_REG, data, mask);
1730
1731         debug_exit();
1732         return;
1733 }
1734
1735 static int comphy_utmi_power_up(u32 utmi_index, void __iomem *utmi_base_addr,
1736                                 void __iomem *usb_cfg_addr,
1737                                 void __iomem *utmi_cfg_addr, u32 utmi_phy_port)
1738 {
1739         u32 data, mask, ret = 1;
1740         void __iomem *addr;
1741
1742         debug_enter();
1743         debug("stage: UTMI %d - Power up transceiver(Power up Phy), and exit SuspendDM\n",
1744               utmi_index);
1745         /* Power UP UTMI PHY */
1746         reg_set(utmi_cfg_addr, 0x1 << UTMI_PHY_CFG_PU_OFFSET,
1747                 UTMI_PHY_CFG_PU_MASK);
1748         /* Disable Test UTMI select */
1749         reg_set(utmi_base_addr + UTMI_CTRL_STATUS0_REG,
1750                 0x0 << UTMI_CTRL_STATUS0_TEST_SEL_OFFSET,
1751                 UTMI_CTRL_STATUS0_TEST_SEL_MASK);
1752
1753         debug("stage: Polling for PLL and impedance calibration done, and PLL ready done\n");
1754         addr = utmi_base_addr + UTMI_CALIB_CTRL_REG;
1755         data = UTMI_CALIB_CTRL_IMPCAL_DONE_MASK;
1756         mask = data;
1757         data = polling_with_timeout(addr, data, mask, 100);
1758         if (data != 0) {
1759                 pr_err("Impedance calibration is not done\n");
1760                 debug("Read from reg = %p - value = 0x%x\n", addr, data);
1761                 ret = 0;
1762         }
1763
1764         data = UTMI_CALIB_CTRL_PLLCAL_DONE_MASK;
1765         mask = data;
1766         data = polling_with_timeout(addr, data, mask, 100);
1767         if (data != 0) {
1768                 pr_err("PLL calibration is not done\n");
1769                 debug("Read from reg = %p - value = 0x%x\n", addr, data);
1770                 ret = 0;
1771         }
1772
1773         addr = utmi_base_addr + UTMI_PLL_CTRL_REG;
1774         data = UTMI_PLL_CTRL_PLL_RDY_MASK;
1775         mask = data;
1776         data = polling_with_timeout(addr, data, mask, 100);
1777         if (data != 0) {
1778                 pr_err("PLL is not ready\n");
1779                 debug("Read from reg = %p - value = 0x%x\n", addr, data);
1780                 ret = 0;
1781         }
1782
1783         if (ret)
1784                 debug("Passed\n");
1785         else
1786                 debug("\n");
1787
1788         debug_exit();
1789         return ret;
1790 }
1791
1792 /*
1793  * comphy_utmi_phy_init initialize the UTMI PHY
1794  * the init split in 3 parts:
1795  * 1. Power down transceiver and PLL
1796  * 2. UTMI PHY configure
1797  * 3. Powe up transceiver and PLL
1798  * Note: - Power down/up should be once for both UTMI PHYs
1799  *       - comphy_dedicated_phys_init call this function if at least there is
1800  *         one UTMI PHY exists in FDT blob. access to cp110_utmi_data[0] is
1801  *         legal
1802  */
1803 static void comphy_utmi_phy_init(u32 utmi_phy_count,
1804                                  struct utmi_phy_data *cp110_utmi_data)
1805 {
1806         u32 i;
1807
1808         debug_enter();
1809         /* UTMI Power down */
1810         for (i = 0; i < utmi_phy_count; i++) {
1811                 comphy_utmi_power_down(i, cp110_utmi_data[i].utmi_base_addr,
1812                                        cp110_utmi_data[i].usb_cfg_addr,
1813                                        cp110_utmi_data[i].utmi_cfg_addr,
1814                                        cp110_utmi_data[i].utmi_phy_port);
1815         }
1816         /* PLL Power down */
1817         debug("stage: UTMI PHY power down PLL\n");
1818         for (i = 0; i < utmi_phy_count; i++) {
1819                 reg_set(cp110_utmi_data[i].usb_cfg_addr,
1820                         0x0 << UTMI_USB_CFG_PLL_OFFSET, UTMI_USB_CFG_PLL_MASK);
1821         }
1822         /* UTMI configure */
1823         for (i = 0; i < utmi_phy_count; i++) {
1824                 comphy_utmi_phy_config(i, cp110_utmi_data[i].utmi_base_addr,
1825                                        cp110_utmi_data[i].usb_cfg_addr,
1826                                        cp110_utmi_data[i].utmi_cfg_addr,
1827                                        cp110_utmi_data[i].utmi_phy_port);
1828         }
1829         /* UTMI Power up */
1830         for (i = 0; i < utmi_phy_count; i++) {
1831                 if (!comphy_utmi_power_up(i, cp110_utmi_data[i].utmi_base_addr,
1832                                           cp110_utmi_data[i].usb_cfg_addr,
1833                                           cp110_utmi_data[i].utmi_cfg_addr,
1834                                           cp110_utmi_data[i].utmi_phy_port)) {
1835                         pr_err("Failed to initialize UTMI PHY %d\n", i);
1836                         continue;
1837                 }
1838                 printf("UTMI PHY %d initialized to ", i);
1839                 if (cp110_utmi_data[i].utmi_phy_port ==
1840                     UTMI_PHY_TO_USB3_DEVICE0)
1841                         printf("USB Device\n");
1842                 else
1843                         printf("USB Host%d\n",
1844                                cp110_utmi_data[i].utmi_phy_port);
1845         }
1846         /* PLL Power up */
1847         debug("stage: UTMI PHY power up PLL\n");
1848         for (i = 0; i < utmi_phy_count; i++) {
1849                 reg_set(cp110_utmi_data[i].usb_cfg_addr,
1850                         0x1 << UTMI_USB_CFG_PLL_OFFSET, UTMI_USB_CFG_PLL_MASK);
1851         }
1852
1853         debug_exit();
1854         return;
1855 }
1856
1857 /*
1858  * comphy_dedicated_phys_init initialize the dedicated PHYs
1859  * - not muxed SerDes lanes e.g. UTMI PHY
1860  */
1861 void comphy_dedicated_phys_init(void)
1862 {
1863         struct utmi_phy_data cp110_utmi_data[MAX_UTMI_PHY_COUNT];
1864         int node;
1865         int i;
1866
1867         debug_enter();
1868         debug("Initialize USB UTMI PHYs\n");
1869
1870         /* Find the UTMI phy node in device tree and go over them */
1871         node = fdt_node_offset_by_compatible(gd->fdt_blob, -1,
1872                                              "marvell,mvebu-utmi-2.6.0");
1873
1874         i = 0;
1875         while (node > 0) {
1876                 /* get base address of UTMI phy */
1877                 cp110_utmi_data[i].utmi_base_addr =
1878                         (void __iomem *)fdtdec_get_addr_size_auto_noparent(
1879                                 gd->fdt_blob, node, "reg", 0, NULL, true);
1880                 if (cp110_utmi_data[i].utmi_base_addr == NULL) {
1881                         pr_err("UTMI PHY base address is invalid\n");
1882                         i++;
1883                         continue;
1884                 }
1885
1886                 /* get usb config address */
1887                 cp110_utmi_data[i].usb_cfg_addr =
1888                         (void __iomem *)fdtdec_get_addr_size_auto_noparent(
1889                                 gd->fdt_blob, node, "reg", 1, NULL, true);
1890                 if (cp110_utmi_data[i].usb_cfg_addr == NULL) {
1891                         pr_err("UTMI PHY base address is invalid\n");
1892                         i++;
1893                         continue;
1894                 }
1895
1896                 /* get UTMI config address */
1897                 cp110_utmi_data[i].utmi_cfg_addr =
1898                         (void __iomem *)fdtdec_get_addr_size_auto_noparent(
1899                                 gd->fdt_blob, node, "reg", 2, NULL, true);
1900                 if (cp110_utmi_data[i].utmi_cfg_addr == NULL) {
1901                         pr_err("UTMI PHY base address is invalid\n");
1902                         i++;
1903                         continue;
1904                 }
1905
1906                 /*
1907                  * get the port number (to check if the utmi connected to
1908                  * host/device)
1909                  */
1910                 cp110_utmi_data[i].utmi_phy_port = fdtdec_get_int(
1911                         gd->fdt_blob, node, "utmi-port", UTMI_PHY_INVALID);
1912                 if (cp110_utmi_data[i].utmi_phy_port == UTMI_PHY_INVALID) {
1913                         pr_err("UTMI PHY port type is invalid\n");
1914                         i++;
1915                         continue;
1916                 }
1917
1918                 node = fdt_node_offset_by_compatible(
1919                         gd->fdt_blob, node, "marvell,mvebu-utmi-2.6.0");
1920                 i++;
1921         }
1922
1923         if (i > 0)
1924                 comphy_utmi_phy_init(i, cp110_utmi_data);
1925
1926         debug_exit();
1927 }
1928
1929 static void comphy_mux_cp110_init(struct chip_serdes_phy_config *ptr_chip_cfg,
1930                                   struct comphy_map *serdes_map)
1931 {
1932         void __iomem *comphy_base_addr;
1933         struct comphy_map comphy_map_pipe_data[MAX_LANE_OPTIONS];
1934         struct comphy_map comphy_map_phy_data[MAX_LANE_OPTIONS];
1935         u32 lane, comphy_max_count;
1936
1937         comphy_max_count = ptr_chip_cfg->comphy_lanes_count;
1938         comphy_base_addr = ptr_chip_cfg->comphy_base_addr;
1939
1940         /*
1941          * Copy the SerDes map configuration for PIPE map and PHY map
1942          * the comphy_mux_init modify the type of the lane if the type
1943          * is not valid because we have 2 selectores run the
1944          * comphy_mux_init twice and after that update the original
1945          * serdes_map
1946          */
1947         for (lane = 0; lane < comphy_max_count; lane++) {
1948                 comphy_map_pipe_data[lane].type = serdes_map[lane].type;
1949                 comphy_map_pipe_data[lane].speed = serdes_map[lane].speed;
1950                 comphy_map_phy_data[lane].type = serdes_map[lane].type;
1951                 comphy_map_phy_data[lane].speed = serdes_map[lane].speed;
1952         }
1953         ptr_chip_cfg->mux_data = cp110_comphy_phy_mux_data;
1954         comphy_mux_init(ptr_chip_cfg, comphy_map_phy_data,
1955                         comphy_base_addr + COMMON_SELECTOR_PHY_OFFSET);
1956
1957         ptr_chip_cfg->mux_data = cp110_comphy_pipe_mux_data;
1958         comphy_mux_init(ptr_chip_cfg, comphy_map_pipe_data,
1959                         comphy_base_addr + COMMON_SELECTOR_PIPE_OFFSET);
1960         /* Fix the type after check the PHY and PIPE configuration */
1961         for (lane = 0; lane < comphy_max_count; lane++) {
1962                 if ((comphy_map_pipe_data[lane].type == PHY_TYPE_UNCONNECTED) &&
1963                     (comphy_map_phy_data[lane].type == PHY_TYPE_UNCONNECTED))
1964                         serdes_map[lane].type = PHY_TYPE_UNCONNECTED;
1965         }
1966 }
1967
1968 int comphy_cp110_init(struct chip_serdes_phy_config *ptr_chip_cfg,
1969                       struct comphy_map *serdes_map)
1970 {
1971         struct comphy_map *ptr_comphy_map;
1972         void __iomem *comphy_base_addr, *hpipe_base_addr;
1973         u32 comphy_max_count, lane, ret = 0;
1974         u32 pcie_width = 0;
1975
1976         debug_enter();
1977
1978         comphy_max_count = ptr_chip_cfg->comphy_lanes_count;
1979         comphy_base_addr = ptr_chip_cfg->comphy_base_addr;
1980         hpipe_base_addr = ptr_chip_cfg->hpipe3_base_addr;
1981
1982         /* Config Comphy mux configuration */
1983         comphy_mux_cp110_init(ptr_chip_cfg, serdes_map);
1984
1985         /* Check if the first 4 lanes configured as By-4 */
1986         for (lane = 0, ptr_comphy_map = serdes_map; lane < 4;
1987              lane++, ptr_comphy_map++) {
1988                 if (ptr_comphy_map->type != PHY_TYPE_PEX0)
1989                         break;
1990                 pcie_width++;
1991         }
1992
1993         for (lane = 0, ptr_comphy_map = serdes_map; lane < comphy_max_count;
1994              lane++, ptr_comphy_map++) {
1995                 debug("Initialize serdes number %d\n", lane);
1996                 debug("Serdes type = 0x%x\n", ptr_comphy_map->type);
1997                 if (lane == 4) {
1998                         /*
1999                          * PCIe lanes above the first 4 lanes, can be only
2000                          * by1
2001                          */
2002                         pcie_width = 1;
2003                 }
2004                 switch (ptr_comphy_map->type) {
2005                 case PHY_TYPE_UNCONNECTED:
2006                 case PHY_TYPE_IGNORE:
2007                         continue;
2008                         break;
2009                 case PHY_TYPE_PEX0:
2010                 case PHY_TYPE_PEX1:
2011                 case PHY_TYPE_PEX2:
2012                 case PHY_TYPE_PEX3:
2013                         ret = comphy_pcie_power_up(
2014                                 lane, pcie_width, ptr_comphy_map->clk_src,
2015                                 serdes_map->end_point,
2016                                 hpipe_base_addr, comphy_base_addr);
2017                         break;
2018                 case PHY_TYPE_SATA0:
2019                 case PHY_TYPE_SATA1:
2020                 case PHY_TYPE_SATA2:
2021                 case PHY_TYPE_SATA3:
2022                         ret = comphy_sata_power_up(
2023                                 lane, hpipe_base_addr, comphy_base_addr,
2024                                 ptr_chip_cfg->cp_index,
2025                                 serdes_map[lane].invert);
2026                         break;
2027                 case PHY_TYPE_USB3_HOST0:
2028                 case PHY_TYPE_USB3_HOST1:
2029                 case PHY_TYPE_USB3_DEVICE:
2030                         ret = comphy_usb3_power_up(lane, hpipe_base_addr,
2031                                                    comphy_base_addr);
2032                         break;
2033                 case PHY_TYPE_SGMII0:
2034                 case PHY_TYPE_SGMII1:
2035                 case PHY_TYPE_SGMII2:
2036                 case PHY_TYPE_SGMII3:
2037                         if (ptr_comphy_map->speed == PHY_SPEED_INVALID) {
2038                                 debug("Warning: SGMII PHY speed in lane %d is invalid, set PHY speed to 1.25G\n",
2039                                       lane);
2040                                 ptr_comphy_map->speed = PHY_SPEED_1_25G;
2041                         }
2042                         ret = comphy_sgmii_power_up(
2043                                 lane, ptr_comphy_map->speed, hpipe_base_addr,
2044                                 comphy_base_addr);
2045                         break;
2046                 case PHY_TYPE_SFI:
2047                         ret = comphy_sfi_power_up(lane, hpipe_base_addr,
2048                                                   comphy_base_addr,
2049                                                   ptr_comphy_map->speed);
2050                         break;
2051                 case PHY_TYPE_RXAUI0:
2052                 case PHY_TYPE_RXAUI1:
2053                         ret = comphy_rxauii_power_up(lane, hpipe_base_addr,
2054                                                      comphy_base_addr);
2055                         break;
2056                 default:
2057                         debug("Unknown SerDes type, skip initialize SerDes %d\n",
2058                               lane);
2059                         break;
2060                 }
2061                 if (ret == 0) {
2062                         /*
2063                          * If interface wans't initialized, set the lane to
2064                          * PHY_TYPE_UNCONNECTED state.
2065                          */
2066                         ptr_comphy_map->type = PHY_TYPE_UNCONNECTED;
2067                         pr_err("PLL is not locked - Failed to initialize lane %d\n",
2068                               lane);
2069                 }
2070         }
2071
2072         debug_exit();
2073         return 0;
2074 }