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