drivers/phy/marvell/comphy_a3700.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 <asm/io.h>
   9 #include <asm/arch/cpu.h>
  10 #include <asm/arch/soc.h>
  11
  12 #include "comphy_a3700.h"
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 struct sgmii_phy_init_data_fix {
  17         u16 addr;
  18         u16 value;
  19 };
  20
  21 /* Changes to 40M1G25 mode data required for running 40M3G125 init mode */
  22 static struct sgmii_phy_init_data_fix sgmii_phy_init_fix[] = {
  23         {0x005, 0x07CC}, {0x015, 0x0000}, {0x01B, 0x0000}, {0x01D, 0x0000},
  24         {0x01E, 0x0000}, {0x01F, 0x0000}, {0x020, 0x0000}, {0x021, 0x0030},
  25         {0x026, 0x0888}, {0x04D, 0x0152}, {0x04F, 0xA020}, {0x050, 0x07CC},
  26         {0x053, 0xE9CA}, {0x055, 0xBD97}, {0x071, 0x3015}, {0x076, 0x03AA},
  27         {0x07C, 0x0FDF}, {0x0C2, 0x3030}, {0x0C3, 0x8000}, {0x0E2, 0x5550},
  28         {0x0E3, 0x12A4}, {0x0E4, 0x7D00}, {0x0E6, 0x0C83}, {0x101, 0xFCC0},
  29         {0x104, 0x0C10}
  30 };
  31
  32 /* 40M1G25 mode init data */
  33 static u16 sgmii_phy_init[512] = {
  34         /* 0       1       2       3       4       5       6       7 */
  35         /*-----------------------------------------------------------*/
  36         /* 8       9       A       B       C       D       E       F */
  37         0x3110, 0xFD83, 0x6430, 0x412F, 0x82C0, 0x06FA, 0x4500, 0x6D26, /* 00 */
  38         0xAFC0, 0x8000, 0xC000, 0x0000, 0x2000, 0x49CC, 0x0BC9, 0x2A52, /* 08 */
  39         0x0BD2, 0x0CDE, 0x13D2, 0x0CE8, 0x1149, 0x10E0, 0x0000, 0x0000, /* 10 */
  40         0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x4134, 0x0D2D, 0xFFFF, /* 18 */
  41         0xFFE0, 0x4030, 0x1016, 0x0030, 0x0000, 0x0800, 0x0866, 0x0000, /* 20 */
  42         0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, /* 28 */
  43         0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 30 */
  44         0x0000, 0x0000, 0x000F, 0x6A62, 0x1988, 0x3100, 0x3100, 0x3100, /* 38 */
  45         0x3100, 0xA708, 0x2430, 0x0830, 0x1030, 0x4610, 0xFF00, 0xFF00, /* 40 */
  46         0x0060, 0x1000, 0x0400, 0x0040, 0x00F0, 0x0155, 0x1100, 0xA02A, /* 48 */
  47         0x06FA, 0x0080, 0xB008, 0xE3ED, 0x5002, 0xB592, 0x7A80, 0x0001, /* 50 */
  48         0x020A, 0x8820, 0x6014, 0x8054, 0xACAA, 0xFC88, 0x2A02, 0x45CF, /* 58 */
  49         0x000F, 0x1817, 0x2860, 0x064F, 0x0000, 0x0204, 0x1800, 0x6000, /* 60 */
  50         0x810F, 0x4F23, 0x4000, 0x4498, 0x0850, 0x0000, 0x000E, 0x1002, /* 68 */
  51         0x9D3A, 0x3009, 0xD066, 0x0491, 0x0001, 0x6AB0, 0x0399, 0x3780, /* 70 */
  52         0x0040, 0x5AC0, 0x4A80, 0x0000, 0x01DF, 0x0000, 0x0007, 0x0000, /* 78 */
  53         0x2D54, 0x00A1, 0x4000, 0x0100, 0xA20A, 0x0000, 0x0000, 0x0000, /* 80 */
  54         0x0000, 0x0000, 0x0000, 0x7400, 0x0E81, 0x1000, 0x1242, 0x0210, /* 88 */
  55         0x80DF, 0x0F1F, 0x2F3F, 0x4F5F, 0x6F7F, 0x0F1F, 0x2F3F, 0x4F5F, /* 90 */
  56         0x6F7F, 0x4BAD, 0x0000, 0x0000, 0x0800, 0x0000, 0x2400, 0xB651, /* 98 */
  57         0xC9E0, 0x4247, 0x0A24, 0x0000, 0xAF19, 0x1004, 0x0000, 0x0000, /* A0 */
  58         0x0000, 0x0013, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* A8 */
  59         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* B0 */
  60         0x0000, 0x0000, 0x0000, 0x0060, 0x0000, 0x0000, 0x0000, 0x0000, /* B8 */
  61         0x0000, 0x0000, 0x3010, 0xFA00, 0x0000, 0x0000, 0x0000, 0x0003, /* C0 */
  62         0x1618, 0x8200, 0x8000, 0x0400, 0x050F, 0x0000, 0x0000, 0x0000, /* C8 */
  63         0x4C93, 0x0000, 0x1000, 0x1120, 0x0010, 0x1242, 0x1242, 0x1E00, /* D0 */
  64         0x0000, 0x0000, 0x0000, 0x00F8, 0x0000, 0x0041, 0x0800, 0x0000, /* D8 */
  65         0x82A0, 0x572E, 0x2490, 0x14A9, 0x4E00, 0x0000, 0x0803, 0x0541, /* E0 */
  66         0x0C15, 0x0000, 0x0000, 0x0400, 0x2626, 0x0000, 0x0000, 0x4200, /* E8 */
  67         0x0000, 0xAA55, 0x1020, 0x0000, 0x0000, 0x5010, 0x0000, 0x0000, /* F0 */
  68         0x0000, 0x0000, 0x5000, 0x0000, 0x0000, 0x0000, 0x02F2, 0x0000, /* F8 */
  69         0x101F, 0xFDC0, 0x4000, 0x8010, 0x0110, 0x0006, 0x0000, 0x0000, /*100 */
  70         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*108 */
  71         0x04CF, 0x0000, 0x04CF, 0x0000, 0x04CF, 0x0000, 0x04C6, 0x0000, /*110 */
  72         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*118 */
  73         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*120 */
  74         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*128 */
  75         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*130 */
  76         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*138 */
  77         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*140 */
  78         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*148 */
  79         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*150 */
  80         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*158 */
  81         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*160 */
  82         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*168 */
  83         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*170 */
  84         0x0000, 0x0000, 0x0000, 0x00F0, 0x08A2, 0x3112, 0x0A14, 0x0000, /*178 */
  85         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*180 */
  86         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*188 */
  87         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*190 */
  88         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*198 */
  89         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1A0 */
  90         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1A8 */
  91         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1B0 */
  92         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1B8 */
  93         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1C0 */
  94         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1C8 */
  95         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1D0 */
  96         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1D8 */
  97         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1E0 */
  98         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1E8 */
  99         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*1F0 */
 100         0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000  /*1F8 */
 101 };
 102
 103 /*
 104  * comphy_poll_reg
 105  *
 106  * return: 1 on success, 0 on timeout
 107  */
 108 static u32 comphy_poll_reg(void *addr, u32 val, u32 mask, u8 op_type)
 109 {
 110         u32 rval = 0xDEAD, timeout;
 111
 112         for (timeout = PLL_LOCK_TIMEOUT; timeout > 0; timeout--) {
 113                 if (op_type == POLL_16B_REG)
 114                         rval = readw(addr);     /* 16 bit */
 115                 else
 116                         rval = readl(addr) ;    /* 32 bit */
 117
 118                 if ((rval & mask) == val)
 119                         return 1;
 120
 121                 udelay(10000);
 122         }
 123
 124         debug("Time out waiting (%p = %#010x)\n", addr, rval);
 125         return 0;
 126 }
 127
 128 /*
 129  * comphy_pcie_power_up
 130  *
 131  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 132  */
 133 static int comphy_pcie_power_up(u32 speed, u32 invert)
 134 {
 135         int ret;
 136
 137         debug_enter();
 138
 139         /*
 140          * 1. Enable max PLL.
 141          */
 142         reg_set16(phy_addr(PCIE, LANE_CFG1), bf_use_max_pll_rate, 0);
 143
 144         /*
 145          * 2. Select 20 bit SERDES interface.
 146          */
 147         reg_set16(phy_addr(PCIE, GLOB_CLK_SRC_LO), bf_cfg_sel_20b, 0);
 148
 149         /*
 150          * 3. Force to use reg setting for PCIe mode
 151          */
 152         reg_set16(phy_addr(PCIE, MISC_REG1), bf_sel_bits_pcie_force, 0);
 153
 154         /*
 155          * 4. Change RX wait
 156          */
 157         reg_set16(phy_addr(PCIE, PWR_MGM_TIM1), 0x10C, 0xFFFF);
 158
 159         /*
 160          * 5. Enable idle sync
 161          */
 162         reg_set16(phy_addr(PCIE, UNIT_CTRL), 0x60 | rb_idle_sync_en, 0xFFFF);
 163
 164         /*
 165          * 6. Enable the output of 100M/125M/500M clock
 166          */
 167         reg_set16(phy_addr(PCIE, MISC_REG0),
 168                   0xA00D | rb_clk500m_en | rb_clk100m_125m_en, 0xFFFF);
 169
 170         /*
 171          * 7. Enable TX
 172          */
 173         reg_set(PCIE_REF_CLK_ADDR, 0x1342, 0xFFFFFFFF);
 174
 175         /*
 176          * 8. Check crystal jumper setting and program the Power and PLL
 177          *    Control accordingly
 178          */
 179         if (get_ref_clk() == 40) {
 180                 /* 40 MHz */
 181                 reg_set16(phy_addr(PCIE, PWR_PLL_CTRL), 0xFC63, 0xFFFF);
 182         } else {
 183                 /* 25 MHz */
 184                 reg_set16(phy_addr(PCIE, PWR_PLL_CTRL), 0xFC62, 0xFFFF);
 185         }
 186
 187         /*
 188          * 9. Override Speed_PLL value and use MAC PLL
 189          */
 190         reg_set16(phy_addr(PCIE, KVCO_CAL_CTRL), 0x0040 | rb_use_max_pll_rate,
 191                   0xFFFF);
 192
 193         /*
 194          * 10. Check the Polarity invert bit
 195          */
 196         if (invert & PHY_POLARITY_TXD_INVERT)
 197                 reg_set16(phy_addr(PCIE, SYNC_PATTERN), phy_txd_inv, 0);
 198
 199         if (invert & PHY_POLARITY_RXD_INVERT)
 200                 reg_set16(phy_addr(PCIE, SYNC_PATTERN), phy_rxd_inv, 0);
 201
 202         /*
 203          * 11. Release SW reset
 204          */
 205         reg_set16(phy_addr(PCIE, GLOB_PHY_CTRL0),
 206                   rb_mode_core_clk_freq_sel | rb_mode_pipe_width_32,
 207                   bf_soft_rst | bf_mode_refdiv);
 208
 209         /* Wait for > 55 us to allow PCLK be enabled */
 210         udelay(PLL_SET_DELAY_US);
 211
 212         /* Assert PCLK enabled */
 213         ret = comphy_poll_reg(phy_addr(PCIE, LANE_STAT1),       /* address */
 214                               rb_txdclk_pclk_en,                /* value */
 215                               rb_txdclk_pclk_en,                /* mask */
 216                               POLL_16B_REG);                    /* 16bit */
 217         if (!ret)
 218                 printf("Failed to lock PCIe PLL\n");
 219
 220         debug_exit();
 221
 222         /* Return the status of the PLL */
 223         return ret;
 224 }
 225
 226 /*
 227  * reg_set_indirect
 228  *
 229  * return: void
 230  */
 231 static void reg_set_indirect(u32 reg, u16 data, u16 mask)
 232 {
 233         reg_set(rh_vsreg_addr, reg, 0xFFFFFFFF);
 234         reg_set(rh_vsreg_data, data, mask);
 235 }
 236
 237 /*
 238  * comphy_sata_power_up
 239  *
 240  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 241  */
 242 static int comphy_sata_power_up(void)
 243 {
 244         int ret;
 245
 246         debug_enter();
 247
 248         /*
 249          * 0. Swap SATA TX lines
 250          */
 251         reg_set_indirect(vphy_sync_pattern_reg, bs_txd_inv, bs_txd_inv);
 252
 253         /*
 254          * 1. Select 40-bit data width width
 255          */
 256         reg_set_indirect(vphy_loopback_reg0, 0x800, bs_phyintf_40bit);
 257
 258         /*
 259          * 2. Select reference clock and PHY mode (SATA)
 260          */
 261         if (get_ref_clk() == 40) {
 262                 /* 40 MHz */
 263                 reg_set_indirect(vphy_power_reg0, 0x3, 0x00FF);
 264         } else {
 265                 /* 20 MHz */
 266                 reg_set_indirect(vphy_power_reg0, 0x1, 0x00FF);
 267         }
 268
 269         /*
 270          * 3. Use maximum PLL rate (no power save)
 271          */
 272         reg_set_indirect(vphy_calctl_reg, bs_max_pll_rate, bs_max_pll_rate);
 273
 274         /*
 275          * 4. Reset reserved bit (??)
 276          */
 277         reg_set_indirect(vphy_reserve_reg, 0, bs_phyctrl_frm_pin);
 278
 279         /*
 280          * 5. Set vendor-specific configuration (??)
 281          */
 282         reg_set(rh_vs0_a, vsata_ctrl_reg, 0xFFFFFFFF);
 283         reg_set(rh_vs0_d, bs_phy_pu_pll, bs_phy_pu_pll);
 284
 285         /* Wait for > 55 us to allow PLL be enabled */
 286         udelay(PLL_SET_DELAY_US);
 287
 288         /* Assert SATA PLL enabled */
 289         reg_set(rh_vsreg_addr, vphy_loopback_reg0, 0xFFFFFFFF);
 290         ret = comphy_poll_reg(rh_vsreg_data,    /* address */
 291                               bs_pll_ready_tx,  /* value */
 292                               bs_pll_ready_tx,  /* mask */
 293                               POLL_32B_REG);    /* 32bit */
 294         if (!ret)
 295                 printf("Failed to lock SATA PLL\n");
 296
 297         debug_exit();
 298
 299         return ret;
 300 }
 301
 302 /*
 303  * usb3_reg_set16
 304  *
 305  * return: void
 306  */
 307 static void usb3_reg_set16(u32 reg, u16 data, u16 mask, u32 lane)
 308 {
 309         /*
 310          * When Lane 2 PHY is for USB3, access the PHY registers
 311          * through indirect Address and Data registers INDIR_ACC_PHY_ADDR
 312          * (RD00E0178h [31:0]) and INDIR_ACC_PHY_DATA (RD00E017Ch [31:0])
 313          * within the SATA Host Controller registers, Lane 2 base register
 314          * offset is 0x200
 315          */
 316
 317         if (lane == 2)
 318                 reg_set_indirect(USB3PHY_LANE2_REG_BASE_OFFSET + reg, data,
 319                                  mask);
 320         else
 321                 reg_set16(phy_addr(USB3, reg), data, mask);
 322 }
 323
 324 /*
 325  * comphy_usb3_power_up
 326  *
 327  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 328  */
 329 static int comphy_usb3_power_up(u32 lane, u32 type, u32 speed, u32 invert)
 330 {
 331         int ret;
 332
 333         debug_enter();
 334
 335         /*
 336          * 1. Power up OTG module
 337          */
 338         reg_set(USB2_PHY_OTG_CTRL_ADDR, rb_pu_otg, 0);
 339
 340         /*
 341          * 2. Set counter for 100us pulse in USB3 Host and Device
 342          * restore default burst size limit (Reference Clock 31:24)
 343          */
 344         reg_set(USB3_CTRPUL_VAL_REG, 0x8 << 24, rb_usb3_ctr_100ns);
 345
 346
 347         /* 0xd005c300 = 0x1001 */
 348         /* set PRD_TXDEEMPH (3.5db de-emph) */
 349         usb3_reg_set16(LANE_CFG0, 0x1, 0xFF, lane);
 350
 351         /*
 352          * unset BIT0: set Tx Electrical Idle Mode: Transmitter is in
 353          *             low impedance mode during electrical idle
 354          * unset BIT4: set G2 Tx Datapath with no Delayed Latency
 355          * unset BIT6: set Tx Detect Rx Mode at LoZ mode
 356          */
 357         usb3_reg_set16(LANE_CFG1, 0x0, 0xFFFF, lane);
 358
 359
 360         /* 0xd005c310 = 0x93: set Spread Spectrum Clock Enabled */
 361         usb3_reg_set16(LANE_CFG4, bf_spread_spectrum_clock_en, 0x80, lane);
 362
 363         /*
 364          * set Override Margining Controls From the MAC: Use margining signals
 365          * from lane configuration
 366          */
 367         usb3_reg_set16(TEST_MODE_CTRL, rb_mode_margin_override, 0xFFFF, lane);
 368
 369         /* set Lane-to-Lane Bundle Clock Sampling Period = per PCLK cycles */
 370         /* set Mode Clock Source = PCLK is generated from REFCLK */
 371         usb3_reg_set16(GLOB_CLK_SRC_LO, 0x0, 0xFF, lane);
 372
 373         /* set G2 Spread Spectrum Clock Amplitude at 4K */
 374         usb3_reg_set16(GEN2_SETTINGS_2, g2_tx_ssc_amp, 0xF000, lane);
 375
 376         /*
 377          * unset G3 Spread Spectrum Clock Amplitude & set G3 TX and RX Register
 378          * Master Current Select
 379          */
 380         usb3_reg_set16(GEN2_SETTINGS_3, 0x0, 0xFFFF, lane);
 381
 382         /*
 383          * 3. Check crystal jumper setting and program the Power and PLL
 384          * Control accordingly
 385          * 4. Change RX wait
 386          */
 387         if (get_ref_clk() == 40) {
 388                 /* 40 MHz */
 389                 usb3_reg_set16(PWR_PLL_CTRL, 0xFCA3, 0xFFFF, lane);
 390                 usb3_reg_set16(PWR_MGM_TIM1, 0x10C, 0xFFFF, lane);
 391         } else {
 392                 /* 25 MHz */
 393                 usb3_reg_set16(PWR_PLL_CTRL, 0xFCA2, 0xFFFF, lane);
 394                 usb3_reg_set16(PWR_MGM_TIM1, 0x107, 0xFFFF, lane);
 395         }
 396
 397         /*
 398          * 5. Enable idle sync
 399          */
 400         usb3_reg_set16(UNIT_CTRL, 0x60 | rb_idle_sync_en, 0xFFFF, lane);
 401
 402         /*
 403          * 6. Enable the output of 500M clock
 404          */
 405         usb3_reg_set16(MISC_REG0, 0xA00D | rb_clk500m_en, 0xFFFF, lane);
 406
 407         /*
 408          * 7. Set 20-bit data width
 409          */
 410         usb3_reg_set16(DIG_LB_EN, 0x0400, 0xFFFF, lane);
 411
 412         /*
 413          * 8. Override Speed_PLL value and use MAC PLL
 414          */
 415         usb3_reg_set16(KVCO_CAL_CTRL, 0x0040 | rb_use_max_pll_rate, 0xFFFF,
 416                        lane);
 417
 418         /*
 419          * 9. Check the Polarity invert bit
 420          */
 421         if (invert & PHY_POLARITY_TXD_INVERT)
 422                 usb3_reg_set16(SYNC_PATTERN, phy_txd_inv, 0, lane);
 423
 424         if (invert & PHY_POLARITY_RXD_INVERT)
 425                 usb3_reg_set16(SYNC_PATTERN, phy_rxd_inv, 0, lane);
 426
 427         /*
 428          * 10. Release SW reset
 429          */
 430         usb3_reg_set16(GLOB_PHY_CTRL0,
 431                        rb_mode_core_clk_freq_sel | rb_mode_pipe_width_32
 432                        | 0x20, 0xFFFF, lane);
 433
 434         /* Wait for > 55 us to allow PCLK be enabled */
 435         udelay(PLL_SET_DELAY_US);
 436
 437         /* Assert PCLK enabled */
 438         if (lane == 2) {
 439                 reg_set(rh_vsreg_addr,
 440                         LANE_STAT1 + USB3PHY_LANE2_REG_BASE_OFFSET,
 441                         0xFFFFFFFF);
 442                 ret = comphy_poll_reg(rh_vsreg_data,            /* address */
 443                                       rb_txdclk_pclk_en,        /* value */
 444                                       rb_txdclk_pclk_en,        /* mask */
 445                                       POLL_32B_REG);            /* 32bit */
 446         } else {
 447                 ret = comphy_poll_reg(phy_addr(USB3, LANE_STAT1), /* address */
 448                                       rb_txdclk_pclk_en,          /* value */
 449                                       rb_txdclk_pclk_en,          /* mask */
 450                                       POLL_16B_REG);              /* 16bit */
 451         }
 452         if (!ret)
 453                 printf("Failed to lock USB3 PLL\n");
 454
 455         /*
 456          * Set Soft ID for Host mode (Device mode works with Hard ID
 457          * detection)
 458          */
 459         if (type == PHY_TYPE_USB3_HOST0) {
 460                 /*
 461                  * set   BIT0: set ID_MODE of Host/Device = "Soft ID" (BIT1)
 462                  * clear BIT1: set SOFT_ID = Host
 463                  * set   BIT4: set INT_MODE = ID. Interrupt Mode: enable
 464                  *             interrupt by ID instead of using both interrupts
 465                  *             of HOST and Device ORed simultaneously
 466                  *             INT_MODE=ID in order to avoid unexpected
 467                  *             behaviour or both interrupts together
 468                  */
 469                 reg_set(USB32_CTRL_BASE,
 470                         usb32_ctrl_id_mode | usb32_ctrl_int_mode,
 471                         usb32_ctrl_id_mode | usb32_ctrl_soft_id |
 472                         usb32_ctrl_int_mode);
 473         }
 474
 475         debug_exit();
 476
 477         return ret;
 478 }
 479
 480 /*
 481  * comphy_usb2_power_up
 482  *
 483  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 484  */
 485 static int comphy_usb2_power_up(u8 usb32)
 486 {
 487         int ret;
 488
 489         debug_enter();
 490
 491         if (usb32 != 0 && usb32 != 1) {
 492                 printf("invalid usb32 value: (%d), should be either 0 or 1\n",
 493                        usb32);
 494                 debug_exit();
 495                 return 0;
 496         }
 497
 498         /*
 499          * 0. Setup PLL. 40MHz clock uses defaults.
 500          *    See "PLL Settings for Typical REFCLK" table
 501          */
 502         if (get_ref_clk() == 25) {
 503                 reg_set(USB2_PHY_BASE(usb32), 5 | (96 << 16),
 504                         0x3F | (0xFF << 16) | (0x3 << 28));
 505         }
 506
 507         /*
 508          * 1. PHY pull up and disable USB2 suspend
 509          */
 510         reg_set(USB2_PHY_CTRL_ADDR(usb32),
 511                 RB_USB2PHY_SUSPM(usb32) | RB_USB2PHY_PU(usb32), 0);
 512
 513         if (usb32 != 0) {
 514                 /*
 515                  * 2. Power up OTG module
 516                  */
 517                 reg_set(USB2_PHY_OTG_CTRL_ADDR, rb_pu_otg, 0);
 518
 519                 /*
 520                  * 3. Configure PHY charger detection
 521                  */
 522                 reg_set(USB2_PHY_CHRGR_DET_ADDR, 0,
 523                         rb_cdp_en | rb_dcp_en | rb_pd_en | rb_cdp_dm_auto |
 524                         rb_enswitch_dp | rb_enswitch_dm | rb_pu_chrg_dtc);
 525         }
 526
 527         /* Assert PLL calibration done */
 528         ret = comphy_poll_reg(USB2_PHY_CAL_CTRL_ADDR(usb32),
 529                               rb_usb2phy_pllcal_done,   /* value */
 530                               rb_usb2phy_pllcal_done,   /* mask */
 531                               POLL_32B_REG);            /* 32bit */
 532         if (!ret)
 533                 printf("Failed to end USB2 PLL calibration\n");
 534
 535         /* Assert impedance calibration done */
 536         ret = comphy_poll_reg(USB2_PHY_CAL_CTRL_ADDR(usb32),
 537                               rb_usb2phy_impcal_done,   /* value */
 538                               rb_usb2phy_impcal_done,   /* mask */
 539                               POLL_32B_REG);            /* 32bit */
 540         if (!ret)
 541                 printf("Failed to end USB2 impedance calibration\n");
 542
 543         /* Assert squetch calibration done */
 544         ret = comphy_poll_reg(USB2_PHY_RX_CHAN_CTRL1_ADDR(usb32),
 545                               rb_usb2phy_sqcal_done,    /* value */
 546                               rb_usb2phy_sqcal_done,    /* mask */
 547                               POLL_32B_REG);            /* 32bit */
 548         if (!ret)
 549                 printf("Failed to end USB2 unknown calibration\n");
 550
 551         /* Assert PLL is ready */
 552         ret = comphy_poll_reg(USB2_PHY_PLL_CTRL0_ADDR(usb32),
 553                               rb_usb2phy_pll_ready,             /* value */
 554                               rb_usb2phy_pll_ready,             /* mask */
 555                               POLL_32B_REG);            /* 32bit */
 556
 557         if (!ret)
 558                 printf("Failed to lock USB2 PLL\n");
 559
 560         debug_exit();
 561
 562         return ret;
 563 }
 564
 565 /*
 566  * comphy_emmc_power_up
 567  *
 568  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 569  */
 570 static int comphy_emmc_power_up(void)
 571 {
 572         debug_enter();
 573
 574         /*
 575          * 1. Bus power ON, Bus voltage 1.8V
 576          */
 577         reg_set(SDIO_HOST_CTRL1_ADDR, 0xB00, 0xF00);
 578
 579         /*
 580          * 2. Set FIFO parameters
 581          */
 582         reg_set(SDIO_SDHC_FIFO_ADDR, 0x315, 0xFFFFFFFF);
 583
 584         /*
 585          * 3. Set Capabilities 1_2
 586          */
 587         reg_set(SDIO_CAP_12_ADDR, 0x25FAC8B2, 0xFFFFFFFF);
 588
 589         /*
 590          * 4. Set Endian
 591          */
 592         reg_set(SDIO_ENDIAN_ADDR, 0x00c00000, 0);
 593
 594         /*
 595          * 4. Init PHY
 596          */
 597         reg_set(SDIO_PHY_TIMING_ADDR, 0x80000000, 0x80000000);
 598         reg_set(SDIO_PHY_PAD_CTRL0_ADDR, 0x50000000, 0xF0000000);
 599
 600         /*
 601          * 5. DLL reset
 602          */
 603         reg_set(SDIO_DLL_RST_ADDR, 0xFFFEFFFF, 0);
 604         reg_set(SDIO_DLL_RST_ADDR, 0x00010000, 0);
 605
 606         debug_exit();
 607
 608         return 1;
 609 }
 610
 611 /*
 612  * comphy_sgmii_power_up
 613  *
 614  * return:
 615  */
 616 static void comphy_sgmii_phy_init(u32 lane, u32 speed)
 617 {
 618         const int fix_arr_sz = ARRAY_SIZE(sgmii_phy_init_fix);
 619         int addr, fix_idx;
 620         u16 val;
 621
 622         fix_idx = 0;
 623         for (addr = 0; addr < 512; addr++) {
 624                 /*
 625                  * All PHY register values are defined in full for 3.125Gbps
 626                  * SERDES speed. The values required for 1.25 Gbps are almost
 627                  * the same and only few registers should be "fixed" in
 628                  * comparison to 3.125 Gbps values. These register values are
 629                  * stored in "sgmii_phy_init_fix" array.
 630                  */
 631                 if ((speed != PHY_SPEED_1_25G) &&
 632                     (sgmii_phy_init_fix[fix_idx].addr == addr)) {
 633                         /* Use new value */
 634                         val = sgmii_phy_init_fix[fix_idx].value;
 635                         if (fix_idx < fix_arr_sz)
 636                                 fix_idx++;
 637                 } else {
 638                         val = sgmii_phy_init[addr];
 639                 }
 640
 641                 reg_set16(sgmiiphy_addr(lane, addr), val, 0xFFFF);
 642         }
 643 }
 644
 645 /*
 646  * comphy_sgmii_power_up
 647  *
 648  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 649  */
 650 static int comphy_sgmii_power_up(u32 lane, u32 speed, u32 invert)
 651 {
 652         int ret;
 653
 654         debug_enter();
 655
 656         /*
 657          * 1. Configure PHY to SATA/SAS mode by setting pin PIN_PIPE_SEL=0
 658          */
 659         reg_set(COMPHY_SEL_ADDR, 0, rf_compy_select(lane));
 660
 661         /*
 662          * 2. Reset PHY by setting PHY input port PIN_RESET=1.
 663          * 3. Set PHY input port PIN_TX_IDLE=1, PIN_PU_IVREF=1 to keep
 664          *    PHY TXP/TXN output to idle state during PHY initialization
 665          * 4. Set PHY input port PIN_PU_PLL=0, PIN_PU_RX=0, PIN_PU_TX=0.
 666          */
 667         reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 668                 rb_pin_reset_comphy | rb_pin_tx_idle | rb_pin_pu_iveref,
 669                 rb_pin_reset_core | rb_pin_pu_pll |
 670                 rb_pin_pu_rx | rb_pin_pu_tx);
 671
 672         /*
 673          * 5. Release reset to the PHY by setting PIN_RESET=0.
 674          */
 675         reg_set(COMPHY_PHY_CFG1_ADDR(lane), 0, rb_pin_reset_comphy);
 676
 677         /*
 678          * 7. Set PIN_PHY_GEN_TX[3:0] and PIN_PHY_GEN_RX[3:0] to decide
 679          *    COMPHY bit rate
 680          */
 681         if (speed == PHY_SPEED_3_125G) { /* 3.125 GHz */
 682                 reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 683                         (0x8 << rf_gen_rx_sel_shift) |
 684                         (0x8 << rf_gen_tx_sel_shift),
 685                         rf_gen_rx_select | rf_gen_tx_select);
 686
 687         } else if (speed == PHY_SPEED_1_25G) { /* 1.25 GHz */
 688                 reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 689                         (0x6 << rf_gen_rx_sel_shift) |
 690                         (0x6 << rf_gen_tx_sel_shift),
 691                         rf_gen_rx_select | rf_gen_tx_select);
 692         } else {
 693                 printf("Unsupported COMPHY speed!\n");
 694                 return 0;
 695         }
 696
 697         /*
 698          * 8. Wait 1mS for bandgap and reference clocks to stabilize;
 699          *    then start SW programming.
 700          */
 701         mdelay(10);
 702
 703         /* 9. Program COMPHY register PHY_MODE */
 704         reg_set16(sgmiiphy_addr(lane, PWR_PLL_CTRL),
 705                   PHY_MODE_SGMII << rf_phy_mode_shift, rf_phy_mode_mask);
 706
 707         /*
 708          * 10. Set COMPHY register REFCLK_SEL to select the correct REFCLK
 709          *     source
 710          */
 711         reg_set16(sgmiiphy_addr(lane, MISC_REG0), 0, rb_ref_clk_sel);
 712
 713         /*
 714          * 11. Set correct reference clock frequency in COMPHY register
 715          *     REF_FREF_SEL.
 716          */
 717         if (get_ref_clk() == 40) {
 718                 reg_set16(sgmiiphy_addr(lane, PWR_PLL_CTRL),
 719                           0x4 << rf_ref_freq_sel_shift, rf_ref_freq_sel_mask);
 720         } else {
 721                 /* 25MHz */
 722                 reg_set16(sgmiiphy_addr(lane, PWR_PLL_CTRL),
 723                           0x1 << rf_ref_freq_sel_shift, rf_ref_freq_sel_mask);
 724         }
 725
 726         /* 12. Program COMPHY register PHY_GEN_MAX[1:0] */
 727         /*
 728          * This step is mentioned in the flow received from verification team.
 729          * However the PHY_GEN_MAX value is only meaningful for other
 730          * interfaces (not SGMII). For instance, it selects SATA speed
 731          * 1.5/3/6 Gbps or PCIe speed  2.5/5 Gbps
 732          */
 733
 734         /*
 735          * 13. Program COMPHY register SEL_BITS to set correct parallel data
 736          *     bus width
 737          */
 738         /* 10bit */
 739         reg_set16(sgmiiphy_addr(lane, DIG_LB_EN), 0, rf_data_width_mask);
 740
 741         /*
 742          * 14. As long as DFE function needs to be enabled in any mode,
 743          *     COMPHY register DFE_UPDATE_EN[5:0] shall be programmed to 0x3F
 744          *     for real chip during COMPHY power on.
 745          */
 746         /*
 747          * The step 14 exists (and empty) in the original initialization flow
 748          * obtained from the verification team. According to the functional
 749          * specification DFE_UPDATE_EN already has the default value 0x3F
 750          */
 751
 752         /*
 753          * 15. Program COMPHY GEN registers.
 754          *     These registers should be programmed based on the lab testing
 755          *     result to achieve optimal performance. Please contact the CEA
 756          *     group to get the related GEN table during real chip bring-up.
 757          *     We only requred to run though the entire registers programming
 758          *     flow defined by "comphy_sgmii_phy_init" when the REF clock is
 759          *     40 MHz. For REF clock 25 MHz the default values stored in PHY
 760          *     registers are OK.
 761          */
 762         debug("Running C-DPI phy init %s mode\n",
 763               speed == PHY_SPEED_3_125G ? "2G5" : "1G");
 764         if (get_ref_clk() == 40)
 765                 comphy_sgmii_phy_init(lane, speed);
 766
 767         /*
 768          * 16. [Simulation Only] should not be used for real chip.
 769          *     By pass power up calibration by programming EXT_FORCE_CAL_DONE
 770          *     (R02h[9]) to 1 to shorten COMPHY simulation time.
 771          */
 772         /*
 773          * 17. [Simulation Only: should not be used for real chip]
 774          *     Program COMPHY register FAST_DFE_TIMER_EN=1 to shorten RX
 775          *     training simulation time.
 776          */
 777
 778         /*
 779          * 18. Check the PHY Polarity invert bit
 780          */
 781         if (invert & PHY_POLARITY_TXD_INVERT)
 782                 reg_set16(sgmiiphy_addr(lane, SYNC_PATTERN), phy_txd_inv, 0);
 783
 784         if (invert & PHY_POLARITY_RXD_INVERT)
 785                 reg_set16(sgmiiphy_addr(lane, SYNC_PATTERN), phy_rxd_inv, 0);
 786
 787         /*
 788          * 19. Set PHY input ports PIN_PU_PLL, PIN_PU_TX and PIN_PU_RX to 1
 789          *     to start PHY power up sequence. All the PHY register
 790          *     programming should be done before PIN_PU_PLL=1. There should be
 791          *     no register programming for normal PHY operation from this point.
 792          */
 793         reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 794                 rb_pin_pu_pll | rb_pin_pu_rx | rb_pin_pu_tx,
 795                 rb_pin_pu_pll | rb_pin_pu_rx | rb_pin_pu_tx);
 796
 797         /*
 798          * 20. Wait for PHY power up sequence to finish by checking output ports
 799          *     PIN_PLL_READY_TX=1 and PIN_PLL_READY_RX=1.
 800          */
 801         ret = comphy_poll_reg(COMPHY_PHY_STAT1_ADDR(lane),      /* address */
 802                               rb_pll_ready_tx | rb_pll_ready_rx, /* value */
 803                               rb_pll_ready_tx | rb_pll_ready_rx, /* mask */
 804                               POLL_32B_REG);                    /* 32bit */
 805         if (!ret)
 806                 printf("Failed to lock PLL for SGMII PHY %d\n", lane);
 807
 808         /*
 809          * 21. Set COMPHY input port PIN_TX_IDLE=0
 810          */
 811         reg_set(COMPHY_PHY_CFG1_ADDR(lane), 0x0, rb_pin_tx_idle);
 812
 813         /*
 814          * 22. After valid data appear on PIN_RXDATA bus, set PIN_RX_INIT=1.
 815          *     to start RX initialization. PIN_RX_INIT_DONE will be cleared to
 816          *     0 by the PHY. After RX initialization is done, PIN_RX_INIT_DONE
 817          *     will be set to 1 by COMPHY. Set PIN_RX_INIT=0 after
 818          *     PIN_RX_INIT_DONE= 1.
 819          *     Please refer to RX initialization part for details.
 820          */
 821         reg_set(COMPHY_PHY_CFG1_ADDR(lane), rb_phy_rx_init, 0x0);
 822
 823         ret = comphy_poll_reg(COMPHY_PHY_STAT1_ADDR(lane), /* address */
 824                               rb_rx_init_done,                  /* value */
 825                               rb_rx_init_done,                  /* mask */
 826                               POLL_32B_REG);                    /* 32bit */
 827         if (!ret)
 828                 printf("Failed to init RX of SGMII PHY %d\n", lane);
 829
 830         debug_exit();
 831
 832         return ret;
 833 }
 834
 835 void comphy_dedicated_phys_init(void)
 836 {
 837         int node, usb32, ret = 1;
 838         const void *blob = gd->fdt_blob;
 839
 840         debug_enter();
 841
 842         for (usb32 = 0; usb32 <= 1; usb32++) {
 843                 /*
 844                  * There are 2 UTMI PHYs in this SOC.
 845                  * One is independendent and one is paired with USB3 port (OTG)
 846                  */
 847                 if (usb32 == 0) {
 848                         node = fdt_node_offset_by_compatible(
 849                                 blob, -1, "marvell,armada-3700-ehci");
 850                 } else {
 851                         node = fdt_node_offset_by_compatible(
 852                                 blob, -1, "marvell,armada3700-xhci");
 853                 }
 854
 855                 if (node > 0) {
 856                         if (fdtdec_get_is_enabled(blob, node)) {
 857                                 ret = comphy_usb2_power_up(usb32);
 858                                 if (!ret)
 859                                         printf("Failed to initialize UTMI PHY\n");
 860                                 else
 861                                         debug("UTMI PHY init succeed\n");
 862                         } else {
 863                                 debug("USB%d node is disabled\n",
 864                                       usb32 == 0 ? 2 : 3);
 865                         }
 866                 } else {
 867                         debug("No USB%d node in DT\n", usb32 == 0 ? 2 : 3);
 868                 }
 869         }
 870
 871         node = fdt_node_offset_by_compatible(blob, -1,
 872                                              "marvell,armada-3700-ahci");
 873         if (node > 0) {
 874                 if (fdtdec_get_is_enabled(blob, node)) {
 875                         ret = comphy_sata_power_up();
 876                         if (!ret)
 877                                 printf("Failed to initialize SATA PHY\n");
 878                         else
 879                                 debug("SATA PHY init succeed\n");
 880                 } else {
 881                         debug("SATA node is disabled\n");
 882                 }
 883         }  else {
 884                 debug("No SATA node in DT\n");
 885         }
 886
 887         node = fdt_node_offset_by_compatible(blob, -1,
 888                                              "marvell,armada-8k-sdhci");
 889         if (node <= 0) {
 890                 node = fdt_node_offset_by_compatible(
 891                         blob, -1, "marvell,armada-3700-sdhci");
 892         }
 893
 894         if (node > 0) {
 895                 if (fdtdec_get_is_enabled(blob, node)) {
 896                         ret = comphy_emmc_power_up();
 897                         if (!ret)
 898                                 printf("Failed to initialize SDIO/eMMC PHY\n");
 899                         else
 900                                 debug("SDIO/eMMC PHY init succeed\n");
 901                 } else {
 902                         debug("SDIO/eMMC node is disabled\n");
 903                 }
 904         }  else {
 905                 debug("No SDIO/eMMC node in DT\n");
 906         }
 907
 908         debug_exit();
 909 }
 910
 911 int comphy_a3700_init(struct chip_serdes_phy_config *chip_cfg,
 912                       struct comphy_map *serdes_map)
 913 {
 914         struct comphy_map *comphy_map;
 915         u32 comphy_max_count = chip_cfg->comphy_lanes_count;
 916         u32 lane, ret = 0;
 917
 918         debug_enter();
 919
 920         for (lane = 0, comphy_map = serdes_map; lane < comphy_max_count;
 921              lane++, comphy_map++) {
 922                 debug("Initialize serdes number %d\n", lane);
 923                 debug("Serdes type = 0x%x invert=%d\n",
 924                       comphy_map->type, comphy_map->invert);
 925
 926                 switch (comphy_map->type) {
 927                 case PHY_TYPE_UNCONNECTED:
 928                         continue;
 929                         break;
 930
 931                 case PHY_TYPE_PEX0:
 932                         ret = comphy_pcie_power_up(comphy_map->speed,
 933                                                    comphy_map->invert);
 934                         break;
 935
 936                 case PHY_TYPE_USB3_HOST0:
 937                 case PHY_TYPE_USB3_DEVICE:
 938                         ret = comphy_usb3_power_up(lane,
 939                                                    comphy_map->type,
 940                                                    comphy_map->speed,
 941                                                    comphy_map->invert);
 942                         break;
 943
 944                 case PHY_TYPE_SGMII0:
 945                 case PHY_TYPE_SGMII1:
 946                         ret = comphy_sgmii_power_up(lane, comphy_map->speed,
 947                                                     comphy_map->invert);
 948                         break;
 949
 950                 default:
 951                         debug("Unknown SerDes type, skip initialize SerDes %d\n",
 952                               lane);
 953                         ret = 1;
 954                         break;
 955                 }
 956                 if (!ret)
 957                         printf("PLL is not locked - Failed to initialize lane %d\n",
 958                                lane);
 959         }
 960
 961         debug_exit();
 962         return ret;
 963 }