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          */
 386         if (get_ref_clk() == 40) {
 387                 /* 40 MHz */
 388                 usb3_reg_set16(PWR_PLL_CTRL, 0xFCA3, 0xFFFF, lane);
 389         } else {
 390                 /* 25 MHz */
 391                 usb3_reg_set16(PWR_PLL_CTRL, 0xFCA2, 0xFFFF, lane);
 392         }
 393
 394         /*
 395          * 4. Change RX wait
 396          */
 397         usb3_reg_set16(PWR_MGM_TIM1, 0x10C, 0xFFFF, lane);
 398
 399         /*
 400          * 5. Enable idle sync
 401          */
 402         usb3_reg_set16(UNIT_CTRL, 0x60 | rb_idle_sync_en, 0xFFFF, lane);
 403
 404         /*
 405          * 6. Enable the output of 500M clock
 406          */
 407         usb3_reg_set16(MISC_REG0, 0xA00D | rb_clk500m_en, 0xFFFF, lane);
 408
 409         /*
 410          * 7. Set 20-bit data width
 411          */
 412         usb3_reg_set16(DIG_LB_EN, 0x0400, 0xFFFF, lane);
 413
 414         /*
 415          * 8. Override Speed_PLL value and use MAC PLL
 416          */
 417         usb3_reg_set16(KVCO_CAL_CTRL, 0x0040 | rb_use_max_pll_rate, 0xFFFF,
 418                        lane);
 419
 420         /*
 421          * 9. Check the Polarity invert bit
 422          */
 423         if (invert & PHY_POLARITY_TXD_INVERT)
 424                 usb3_reg_set16(SYNC_PATTERN, phy_txd_inv, 0, lane);
 425
 426         if (invert & PHY_POLARITY_RXD_INVERT)
 427                 usb3_reg_set16(SYNC_PATTERN, phy_rxd_inv, 0, lane);
 428
 429         /*
 430          * 10. Release SW reset
 431          */
 432         usb3_reg_set16(GLOB_PHY_CTRL0,
 433                        rb_mode_core_clk_freq_sel | rb_mode_pipe_width_32
 434                        | 0x20, 0xFFFF, lane);
 435
 436         /* Wait for > 55 us to allow PCLK be enabled */
 437         udelay(PLL_SET_DELAY_US);
 438
 439         /* Assert PCLK enabled */
 440         if (lane == 2) {
 441                 reg_set(rh_vsreg_addr,
 442                         LANE_STAT1 + USB3PHY_LANE2_REG_BASE_OFFSET,
 443                         0xFFFFFFFF);
 444                 ret = comphy_poll_reg(rh_vsreg_data,            /* address */
 445                                       rb_txdclk_pclk_en,        /* value */
 446                                       rb_txdclk_pclk_en,        /* mask */
 447                                       POLL_32B_REG);            /* 32bit */
 448         } else {
 449                 ret = comphy_poll_reg(phy_addr(USB3, LANE_STAT1), /* address */
 450                                       rb_txdclk_pclk_en,          /* value */
 451                                       rb_txdclk_pclk_en,          /* mask */
 452                                       POLL_16B_REG);              /* 16bit */
 453         }
 454         if (!ret)
 455                 printf("Failed to lock USB3 PLL\n");
 456
 457         /*
 458          * Set Soft ID for Host mode (Device mode works with Hard ID
 459          * detection)
 460          */
 461         if (type == PHY_TYPE_USB3_HOST0) {
 462                 /*
 463                  * set   BIT0: set ID_MODE of Host/Device = "Soft ID" (BIT1)
 464                  * clear BIT1: set SOFT_ID = Host
 465                  * set   BIT4: set INT_MODE = ID. Interrupt Mode: enable
 466                  *             interrupt by ID instead of using both interrupts
 467                  *             of HOST and Device ORed simultaneously
 468                  *             INT_MODE=ID in order to avoid unexpected
 469                  *             behaviour or both interrupts together
 470                  */
 471                 reg_set(USB32_CTRL_BASE,
 472                         usb32_ctrl_id_mode | usb32_ctrl_int_mode,
 473                         usb32_ctrl_id_mode | usb32_ctrl_soft_id |
 474                         usb32_ctrl_int_mode);
 475         }
 476
 477         debug_exit();
 478
 479         return ret;
 480 }
 481
 482 /*
 483  * comphy_usb2_power_up
 484  *
 485  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 486  */
 487 static int comphy_usb2_power_up(u8 usb32)
 488 {
 489         int ret;
 490
 491         debug_enter();
 492
 493         if (usb32 != 0 && usb32 != 1) {
 494                 printf("invalid usb32 value: (%d), should be either 0 or 1\n",
 495                        usb32);
 496                 debug_exit();
 497                 return 0;
 498         }
 499
 500         /*
 501          * 0. Setup PLL. 40MHz clock uses defaults.
 502          *    See "PLL Settings for Typical REFCLK" table
 503          */
 504         if (get_ref_clk() == 25) {
 505                 reg_set(USB2_PHY_BASE(usb32), 5 | (96 << 16),
 506                         0x3F | (0xFF << 16) | (0x3 << 28));
 507         }
 508
 509         /*
 510          * 1. PHY pull up and disable USB2 suspend
 511          */
 512         reg_set(USB2_PHY_CTRL_ADDR(usb32),
 513                 RB_USB2PHY_SUSPM(usb32) | RB_USB2PHY_PU(usb32), 0);
 514
 515         if (usb32 != 0) {
 516                 /*
 517                  * 2. Power up OTG module
 518                  */
 519                 reg_set(USB2_PHY_OTG_CTRL_ADDR, rb_pu_otg, 0);
 520
 521                 /*
 522                  * 3. Configure PHY charger detection
 523                  */
 524                 reg_set(USB2_PHY_CHRGR_DET_ADDR, 0,
 525                         rb_cdp_en | rb_dcp_en | rb_pd_en | rb_cdp_dm_auto |
 526                         rb_enswitch_dp | rb_enswitch_dm | rb_pu_chrg_dtc);
 527         }
 528
 529         /* Assert PLL calibration done */
 530         ret = comphy_poll_reg(USB2_PHY_CAL_CTRL_ADDR(usb32),
 531                               rb_usb2phy_pllcal_done,   /* value */
 532                               rb_usb2phy_pllcal_done,   /* mask */
 533                               POLL_32B_REG);            /* 32bit */
 534         if (!ret)
 535                 printf("Failed to end USB2 PLL calibration\n");
 536
 537         /* Assert impedance calibration done */
 538         ret = comphy_poll_reg(USB2_PHY_CAL_CTRL_ADDR(usb32),
 539                               rb_usb2phy_impcal_done,   /* value */
 540                               rb_usb2phy_impcal_done,   /* mask */
 541                               POLL_32B_REG);            /* 32bit */
 542         if (!ret)
 543                 printf("Failed to end USB2 impedance calibration\n");
 544
 545         /* Assert squetch calibration done */
 546         ret = comphy_poll_reg(USB2_PHY_RX_CHAN_CTRL1_ADDR(usb32),
 547                               rb_usb2phy_sqcal_done,    /* value */
 548                               rb_usb2phy_sqcal_done,    /* mask */
 549                               POLL_32B_REG);            /* 32bit */
 550         if (!ret)
 551                 printf("Failed to end USB2 unknown calibration\n");
 552
 553         /* Assert PLL is ready */
 554         ret = comphy_poll_reg(USB2_PHY_PLL_CTRL0_ADDR(usb32),
 555                               rb_usb2phy_pll_ready,             /* value */
 556                               rb_usb2phy_pll_ready,             /* mask */
 557                               POLL_32B_REG);            /* 32bit */
 558
 559         if (!ret)
 560                 printf("Failed to lock USB2 PLL\n");
 561
 562         debug_exit();
 563
 564         return ret;
 565 }
 566
 567 /*
 568  * comphy_emmc_power_up
 569  *
 570  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 571  */
 572 static int comphy_emmc_power_up(void)
 573 {
 574         debug_enter();
 575
 576         /*
 577          * 1. Bus power ON, Bus voltage 1.8V
 578          */
 579         reg_set(SDIO_HOST_CTRL1_ADDR, 0xB00, 0xF00);
 580
 581         /*
 582          * 2. Set FIFO parameters
 583          */
 584         reg_set(SDIO_SDHC_FIFO_ADDR, 0x315, 0xFFFFFFFF);
 585
 586         /*
 587          * 3. Set Capabilities 1_2
 588          */
 589         reg_set(SDIO_CAP_12_ADDR, 0x25FAC8B2, 0xFFFFFFFF);
 590
 591         /*
 592          * 4. Set Endian
 593          */
 594         reg_set(SDIO_ENDIAN_ADDR, 0x00c00000, 0);
 595
 596         /*
 597          * 4. Init PHY
 598          */
 599         reg_set(SDIO_PHY_TIMING_ADDR, 0x80000000, 0x80000000);
 600         reg_set(SDIO_PHY_PAD_CTRL0_ADDR, 0x50000000, 0xF0000000);
 601
 602         /*
 603          * 5. DLL reset
 604          */
 605         reg_set(SDIO_DLL_RST_ADDR, 0xFFFEFFFF, 0);
 606         reg_set(SDIO_DLL_RST_ADDR, 0x00010000, 0);
 607
 608         debug_exit();
 609
 610         return 1;
 611 }
 612
 613 /*
 614  * comphy_sgmii_power_up
 615  *
 616  * return:
 617  */
 618 static void comphy_sgmii_phy_init(u32 lane, u32 speed)
 619 {
 620         const int fix_arr_sz = ARRAY_SIZE(sgmii_phy_init_fix);
 621         int addr, fix_idx;
 622         u16 val;
 623
 624         fix_idx = 0;
 625         for (addr = 0; addr < 512; addr++) {
 626                 /*
 627                  * All PHY register values are defined in full for 3.125Gbps
 628                  * SERDES speed. The values required for 1.25 Gbps are almost
 629                  * the same and only few registers should be "fixed" in
 630                  * comparison to 3.125 Gbps values. These register values are
 631                  * stored in "sgmii_phy_init_fix" array.
 632                  */
 633                 if ((speed != PHY_SPEED_1_25G) &&
 634                     (sgmii_phy_init_fix[fix_idx].addr == addr)) {
 635                         /* Use new value */
 636                         val = sgmii_phy_init_fix[fix_idx].value;
 637                         if (fix_idx < fix_arr_sz)
 638                                 fix_idx++;
 639                 } else {
 640                         val = sgmii_phy_init[addr];
 641                 }
 642
 643                 reg_set16(sgmiiphy_addr(lane, addr), val, 0xFFFF);
 644         }
 645 }
 646
 647 /*
 648  * comphy_sgmii_power_up
 649  *
 650  * return: 1 if PLL locked (OK), 0 otherwise (FAIL)
 651  */
 652 static int comphy_sgmii_power_up(u32 lane, u32 speed, u32 invert)
 653 {
 654         int ret;
 655
 656         debug_enter();
 657
 658         /*
 659          * 1. Configure PHY to SATA/SAS mode by setting pin PIN_PIPE_SEL=0
 660          */
 661         reg_set(COMPHY_SEL_ADDR, 0, rf_compy_select(lane));
 662
 663         /*
 664          * 2. Reset PHY by setting PHY input port PIN_RESET=1.
 665          * 3. Set PHY input port PIN_TX_IDLE=1, PIN_PU_IVREF=1 to keep
 666          *    PHY TXP/TXN output to idle state during PHY initialization
 667          * 4. Set PHY input port PIN_PU_PLL=0, PIN_PU_RX=0, PIN_PU_TX=0.
 668          */
 669         reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 670                 rb_pin_reset_comphy | rb_pin_tx_idle | rb_pin_pu_iveref,
 671                 rb_pin_reset_core | rb_pin_pu_pll |
 672                 rb_pin_pu_rx | rb_pin_pu_tx);
 673
 674         /*
 675          * 5. Release reset to the PHY by setting PIN_RESET=0.
 676          */
 677         reg_set(COMPHY_PHY_CFG1_ADDR(lane), 0, rb_pin_reset_comphy);
 678
 679         /*
 680          * 7. Set PIN_PHY_GEN_TX[3:0] and PIN_PHY_GEN_RX[3:0] to decide
 681          *    COMPHY bit rate
 682          */
 683         if (speed == PHY_SPEED_3_125G) { /* 3.125 GHz */
 684                 reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 685                         (0x8 << rf_gen_rx_sel_shift) |
 686                         (0x8 << rf_gen_tx_sel_shift),
 687                         rf_gen_rx_select | rf_gen_tx_select);
 688
 689         } else if (speed == PHY_SPEED_1_25G) { /* 1.25 GHz */
 690                 reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 691                         (0x6 << rf_gen_rx_sel_shift) |
 692                         (0x6 << rf_gen_tx_sel_shift),
 693                         rf_gen_rx_select | rf_gen_tx_select);
 694         } else {
 695                 printf("Unsupported COMPHY speed!\n");
 696                 return 0;
 697         }
 698
 699         /*
 700          * 8. Wait 1mS for bandgap and reference clocks to stabilize;
 701          *    then start SW programming.
 702          */
 703         mdelay(10);
 704
 705         /* 9. Program COMPHY register PHY_MODE */
 706         reg_set16(sgmiiphy_addr(lane, PWR_PLL_CTRL),
 707                   PHY_MODE_SGMII << rf_phy_mode_shift, rf_phy_mode_mask);
 708
 709         /*
 710          * 10. Set COMPHY register REFCLK_SEL to select the correct REFCLK
 711          *     source
 712          */
 713         reg_set16(sgmiiphy_addr(lane, MISC_REG0), 0, rb_ref_clk_sel);
 714
 715         /*
 716          * 11. Set correct reference clock frequency in COMPHY register
 717          *     REF_FREF_SEL.
 718          */
 719         if (get_ref_clk() == 40) {
 720                 reg_set16(sgmiiphy_addr(lane, PWR_PLL_CTRL),
 721                           0x4 << rf_ref_freq_sel_shift, rf_ref_freq_sel_mask);
 722         } else {
 723                 /* 25MHz */
 724                 reg_set16(sgmiiphy_addr(lane, PWR_PLL_CTRL),
 725                           0x1 << rf_ref_freq_sel_shift, rf_ref_freq_sel_mask);
 726         }
 727
 728         /* 12. Program COMPHY register PHY_GEN_MAX[1:0] */
 729         /*
 730          * This step is mentioned in the flow received from verification team.
 731          * However the PHY_GEN_MAX value is only meaningful for other
 732          * interfaces (not SGMII). For instance, it selects SATA speed
 733          * 1.5/3/6 Gbps or PCIe speed  2.5/5 Gbps
 734          */
 735
 736         /*
 737          * 13. Program COMPHY register SEL_BITS to set correct parallel data
 738          *     bus width
 739          */
 740         /* 10bit */
 741         reg_set16(sgmiiphy_addr(lane, DIG_LB_EN), 0, rf_data_width_mask);
 742
 743         /*
 744          * 14. As long as DFE function needs to be enabled in any mode,
 745          *     COMPHY register DFE_UPDATE_EN[5:0] shall be programmed to 0x3F
 746          *     for real chip during COMPHY power on.
 747          */
 748         /*
 749          * The step 14 exists (and empty) in the original initialization flow
 750          * obtained from the verification team. According to the functional
 751          * specification DFE_UPDATE_EN already has the default value 0x3F
 752          */
 753
 754         /*
 755          * 15. Program COMPHY GEN registers.
 756          *     These registers should be programmed based on the lab testing
 757          *     result to achieve optimal performance. Please contact the CEA
 758          *     group to get the related GEN table during real chip bring-up.
 759          *     We only requred to run though the entire registers programming
 760          *     flow defined by "comphy_sgmii_phy_init" when the REF clock is
 761          *     40 MHz. For REF clock 25 MHz the default values stored in PHY
 762          *     registers are OK.
 763          */
 764         debug("Running C-DPI phy init %s mode\n",
 765               speed == PHY_SPEED_3_125G ? "2G5" : "1G");
 766         if (get_ref_clk() == 40)
 767                 comphy_sgmii_phy_init(lane, speed);
 768
 769         /*
 770          * 16. [Simulation Only] should not be used for real chip.
 771          *     By pass power up calibration by programming EXT_FORCE_CAL_DONE
 772          *     (R02h[9]) to 1 to shorten COMPHY simulation time.
 773          */
 774         /*
 775          * 17. [Simulation Only: should not be used for real chip]
 776          *     Program COMPHY register FAST_DFE_TIMER_EN=1 to shorten RX
 777          *     training simulation time.
 778          */
 779
 780         /*
 781          * 18. Check the PHY Polarity invert bit
 782          */
 783         if (invert & PHY_POLARITY_TXD_INVERT)
 784                 reg_set16(sgmiiphy_addr(lane, SYNC_PATTERN), phy_txd_inv, 0);
 785
 786         if (invert & PHY_POLARITY_RXD_INVERT)
 787                 reg_set16(sgmiiphy_addr(lane, SYNC_PATTERN), phy_rxd_inv, 0);
 788
 789         /*
 790          * 19. Set PHY input ports PIN_PU_PLL, PIN_PU_TX and PIN_PU_RX to 1
 791          *     to start PHY power up sequence. All the PHY register
 792          *     programming should be done before PIN_PU_PLL=1. There should be
 793          *     no register programming for normal PHY operation from this point.
 794          */
 795         reg_set(COMPHY_PHY_CFG1_ADDR(lane),
 796                 rb_pin_pu_pll | rb_pin_pu_rx | rb_pin_pu_tx,
 797                 rb_pin_pu_pll | rb_pin_pu_rx | rb_pin_pu_tx);
 798
 799         /*
 800          * 20. Wait for PHY power up sequence to finish by checking output ports
 801          *     PIN_PLL_READY_TX=1 and PIN_PLL_READY_RX=1.
 802          */
 803         ret = comphy_poll_reg(COMPHY_PHY_STAT1_ADDR(lane),      /* address */
 804                               rb_pll_ready_tx | rb_pll_ready_rx, /* value */
 805                               rb_pll_ready_tx | rb_pll_ready_rx, /* mask */
 806                               POLL_32B_REG);                    /* 32bit */
 807         if (!ret)
 808                 printf("Failed to lock PLL for SGMII PHY %d\n", lane);
 809
 810         /*
 811          * 21. Set COMPHY input port PIN_TX_IDLE=0
 812          */
 813         reg_set(COMPHY_PHY_CFG1_ADDR(lane), 0x0, rb_pin_tx_idle);
 814
 815         /*
 816          * 22. After valid data appear on PIN_RXDATA bus, set PIN_RX_INIT=1.
 817          *     to start RX initialization. PIN_RX_INIT_DONE will be cleared to
 818          *     0 by the PHY. After RX initialization is done, PIN_RX_INIT_DONE
 819          *     will be set to 1 by COMPHY. Set PIN_RX_INIT=0 after
 820          *     PIN_RX_INIT_DONE= 1.
 821          *     Please refer to RX initialization part for details.
 822          */
 823         reg_set(COMPHY_PHY_CFG1_ADDR(lane), rb_phy_rx_init, 0x0);
 824
 825         ret = comphy_poll_reg(COMPHY_PHY_STAT1_ADDR(lane), /* address */
 826                               rb_rx_init_done,                  /* value */
 827                               rb_rx_init_done,                  /* mask */
 828                               POLL_32B_REG);                    /* 32bit */
 829         if (!ret)
 830                 printf("Failed to init RX of SGMII PHY %d\n", lane);
 831
 832         debug_exit();
 833
 834         return ret;
 835 }
 836
 837 void comphy_dedicated_phys_init(void)
 838 {
 839         int node, usb32, ret = 1;
 840         const void *blob = gd->fdt_blob;
 841
 842         debug_enter();
 843
 844         for (usb32 = 0; usb32 <= 1; usb32++) {
 845                 /*
 846                  * There are 2 UTMI PHYs in this SOC.
 847                  * One is independendent and one is paired with USB3 port (OTG)
 848                  */
 849                 if (usb32 == 0) {
 850                         node = fdt_node_offset_by_compatible(
 851                                 blob, -1, "marvell,armada-3700-ehci");
 852                 } else {
 853                         node = fdt_node_offset_by_compatible(
 854                                 blob, -1, "marvell,armada3700-xhci");
 855                 }
 856
 857                 if (node > 0) {
 858                         if (fdtdec_get_is_enabled(blob, node)) {
 859                                 ret = comphy_usb2_power_up(usb32);
 860                                 if (!ret)
 861                                         printf("Failed to initialize UTMI PHY\n");
 862                                 else
 863                                         debug("UTMI PHY init succeed\n");
 864                         } else {
 865                                 debug("USB%d node is disabled\n",
 866                                       usb32 == 0 ? 2 : 3);
 867                         }
 868                 } else {
 869                         debug("No USB%d node in DT\n", usb32 == 0 ? 2 : 3);
 870                 }
 871         }
 872
 873         node = fdt_node_offset_by_compatible(blob, -1,
 874                                              "marvell,armada-3700-ahci");
 875         if (node > 0) {
 876                 if (fdtdec_get_is_enabled(blob, node)) {
 877                         ret = comphy_sata_power_up();
 878                         if (!ret)
 879                                 printf("Failed to initialize SATA PHY\n");
 880                         else
 881                                 debug("SATA PHY init succeed\n");
 882                 } else {
 883                         debug("SATA node is disabled\n");
 884                 }
 885         }  else {
 886                 debug("No SATA node in DT\n");
 887         }
 888
 889         node = fdt_node_offset_by_compatible(blob, -1,
 890                                              "marvell,armada-8k-sdhci");
 891         if (node <= 0) {
 892                 node = fdt_node_offset_by_compatible(
 893                         blob, -1, "marvell,armada-3700-sdhci");
 894         }
 895
 896         if (node > 0) {
 897                 if (fdtdec_get_is_enabled(blob, node)) {
 898                         ret = comphy_emmc_power_up();
 899                         if (!ret)
 900                                 printf("Failed to initialize SDIO/eMMC PHY\n");
 901                         else
 902                                 debug("SDIO/eMMC PHY init succeed\n");
 903                 } else {
 904                         debug("SDIO/eMMC node is disabled\n");
 905                 }
 906         }  else {
 907                 debug("No SDIO/eMMC node in DT\n");
 908         }
 909
 910         debug_exit();
 911 }
 912
 913 int comphy_a3700_init(struct chip_serdes_phy_config *chip_cfg,
 914                       struct comphy_map *serdes_map)
 915 {
 916         struct comphy_map *comphy_map;
 917         u32 comphy_max_count = chip_cfg->comphy_lanes_count;
 918         u32 lane, ret = 0;
 919
 920         debug_enter();
 921
 922         for (lane = 0, comphy_map = serdes_map; lane < comphy_max_count;
 923              lane++, comphy_map++) {
 924                 debug("Initialize serdes number %d\n", lane);
 925                 debug("Serdes type = 0x%x invert=%d\n",
 926                       comphy_map->type, comphy_map->invert);
 927
 928                 switch (comphy_map->type) {
 929                 case PHY_TYPE_UNCONNECTED:
 930                         continue;
 931                         break;
 932
 933                 case PHY_TYPE_PEX0:
 934                         ret = comphy_pcie_power_up(comphy_map->speed,
 935                                                    comphy_map->invert);
 936                         break;
 937
 938                 case PHY_TYPE_USB3_HOST0:
 939                 case PHY_TYPE_USB3_DEVICE:
 940                         ret = comphy_usb3_power_up(lane,
 941                                                    comphy_map->type,
 942                                                    comphy_map->speed,
 943                                                    comphy_map->invert);
 944                         break;
 945
 946                 case PHY_TYPE_SGMII0:
 947                 case PHY_TYPE_SGMII1:
 948                         ret = comphy_sgmii_power_up(lane, comphy_map->speed,
 949                                                     comphy_map->invert);
 950                         break;
 951
 952                 default:
 953                         debug("Unknown SerDes type, skip initialize SerDes %d\n",
 954                               lane);
 955                         ret = 1;
 956                         break;
 957                 }
 958                 if (!ret)
 959                         printf("PLL is not locked - Failed to initialize lane %d\n",
 960                                lane);
 961         }
 962
 963         debug_exit();
 964         return ret;
 965 }