drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2016, The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/clk.h>
   7 #include <linux/clk-provider.h>
   8 #include <linux/delay.h>
   9
  10 #include "dsi_phy.h"
  11 #include "dsi.xml.h"
  12
  13 #define PHY_14NM_CKLN_IDX       4
  14
  15 /*
  16  * DSI PLL 14nm - clock diagram (eg: DSI0):
  17  *
  18  *         dsi0n1_postdiv_clk
  19  *                         |
  20  *                         |
  21  *                 +----+  |  +----+
  22  *  dsi0vco_clk ---| n1 |--o--| /8 |-- dsi0pllbyte
  23  *                 +----+  |  +----+
  24  *                         |           dsi0n1_postdivby2_clk
  25  *                         |   +----+  |
  26  *                         o---| /2 |--o--|\
  27  *                         |   +----+     | \   +----+
  28  *                         |              |  |--| n2 |-- dsi0pll
  29  *                         o--------------| /   +----+
  30  *                                        |/
  31  */
  32
  33 #define POLL_MAX_READS                  15
  34 #define POLL_TIMEOUT_US                 1000
  35
  36 #define VCO_REF_CLK_RATE                19200000
  37 #define VCO_MIN_RATE                    1300000000UL
  38 #define VCO_MAX_RATE                    2600000000UL
  39
  40 #define DSI_PLL_DEFAULT_VCO_POSTDIV     1
  41
  42 struct dsi_pll_input {
  43         u32 fref;       /* reference clk */
  44         u32 fdata;      /* bit clock rate */
  45         u32 dsiclk_sel; /* Mux configuration (see diagram) */
  46         u32 ssc_en;     /* SSC enable/disable */
  47         u32 ldo_en;
  48
  49         /* fixed params */
  50         u32 refclk_dbler_en;
  51         u32 vco_measure_time;
  52         u32 kvco_measure_time;
  53         u32 bandgap_timer;
  54         u32 pll_wakeup_timer;
  55         u32 plllock_cnt;
  56         u32 plllock_rng;
  57         u32 ssc_center;
  58         u32 ssc_adj_period;
  59         u32 ssc_spread;
  60         u32 ssc_freq;
  61         u32 pll_ie_trim;
  62         u32 pll_ip_trim;
  63         u32 pll_iptat_trim;
  64         u32 pll_cpcset_cur;
  65         u32 pll_cpmset_cur;
  66
  67         u32 pll_icpmset;
  68         u32 pll_icpcset;
  69
  70         u32 pll_icpmset_p;
  71         u32 pll_icpmset_m;
  72
  73         u32 pll_icpcset_p;
  74         u32 pll_icpcset_m;
  75
  76         u32 pll_lpf_res1;
  77         u32 pll_lpf_cap1;
  78         u32 pll_lpf_cap2;
  79         u32 pll_c3ctrl;
  80         u32 pll_r3ctrl;
  81 };
  82
  83 struct dsi_pll_output {
  84         u32 pll_txclk_en;
  85         u32 dec_start;
  86         u32 div_frac_start;
  87         u32 ssc_period;
  88         u32 ssc_step_size;
  89         u32 plllock_cmp;
  90         u32 pll_vco_div_ref;
  91         u32 pll_vco_count;
  92         u32 pll_kvco_div_ref;
  93         u32 pll_kvco_count;
  94         u32 pll_misc1;
  95         u32 pll_lpf2_postdiv;
  96         u32 pll_resetsm_cntrl;
  97         u32 pll_resetsm_cntrl2;
  98         u32 pll_resetsm_cntrl5;
  99         u32 pll_kvco_code;
 100
 101         u32 cmn_clk_cfg0;
 102         u32 cmn_clk_cfg1;
 103         u32 cmn_ldo_cntrl;
 104
 105         u32 pll_postdiv;
 106         u32 fcvo;
 107 };
 108
 109 struct pll_14nm_cached_state {
 110         unsigned long vco_rate;
 111         u8 n2postdiv;
 112         u8 n1postdiv;
 113 };
 114
 115 struct dsi_pll_14nm {
 116         struct clk_hw clk_hw;
 117
 118         int id;
 119         struct platform_device *pdev;
 120
 121         void __iomem *phy_cmn_mmio;
 122         void __iomem *mmio;
 123
 124         struct msm_dsi_phy *phy;
 125
 126         struct dsi_pll_input in;
 127         struct dsi_pll_output out;
 128
 129         /* protects REG_DSI_14nm_PHY_CMN_CLK_CFG0 register */
 130         spinlock_t postdiv_lock;
 131
 132         u64 vco_current_rate;
 133         u64 vco_ref_clk_rate;
 134
 135         struct pll_14nm_cached_state cached_state;
 136
 137         struct dsi_pll_14nm *slave;
 138 };
 139
 140 #define to_pll_14nm(x)  container_of(x, struct dsi_pll_14nm, clk_hw)
 141
 142 /*
 143  * Private struct for N1/N2 post-divider clocks. These clocks are similar to
 144  * the generic clk_divider class of clocks. The only difference is that it
 145  * also sets the slave DSI PLL's post-dividers if in Dual DSI mode
 146  */
 147 struct dsi_pll_14nm_postdiv {
 148         struct clk_hw hw;
 149
 150         /* divider params */
 151         u8 shift;
 152         u8 width;
 153         u8 flags; /* same flags as used by clk_divider struct */
 154
 155         struct dsi_pll_14nm *pll;
 156 };
 157
 158 #define to_pll_14nm_postdiv(_hw) container_of(_hw, struct dsi_pll_14nm_postdiv, hw)
 159
 160 /*
 161  * Global list of private DSI PLL struct pointers. We need this for Dual DSI
 162  * mode, where the master PLL's clk_ops needs access the slave's private data
 163  */
 164 static struct dsi_pll_14nm *pll_14nm_list[DSI_MAX];
 165
 166 static bool pll_14nm_poll_for_ready(struct dsi_pll_14nm *pll_14nm,
 167                                     u32 nb_tries, u32 timeout_us)
 168 {
 169         bool pll_locked = false;
 170         void __iomem *base = pll_14nm->mmio;
 171         u32 tries, val;
 172
 173         tries = nb_tries;
 174         while (tries--) {
 175                 val = dsi_phy_read(base +
 176                                REG_DSI_14nm_PHY_PLL_RESET_SM_READY_STATUS);
 177                 pll_locked = !!(val & BIT(5));
 178
 179                 if (pll_locked)
 180                         break;
 181
 182                 udelay(timeout_us);
 183         }
 184
 185         if (!pll_locked) {
 186                 tries = nb_tries;
 187                 while (tries--) {
 188                         val = dsi_phy_read(base +
 189                                 REG_DSI_14nm_PHY_PLL_RESET_SM_READY_STATUS);
 190                         pll_locked = !!(val & BIT(0));
 191
 192                         if (pll_locked)
 193                                 break;
 194
 195                         udelay(timeout_us);
 196                 }
 197         }
 198
 199         DBG("DSI PLL is %slocked", pll_locked ? "" : "*not* ");
 200
 201         return pll_locked;
 202 }
 203
 204 static void dsi_pll_14nm_input_init(struct dsi_pll_14nm *pll)
 205 {
 206         pll->in.fref = pll->vco_ref_clk_rate;
 207         pll->in.fdata = 0;
 208         pll->in.dsiclk_sel = 1; /* Use the /2 path in Mux */
 209         pll->in.ldo_en = 0;     /* disabled for now */
 210
 211         /* fixed input */
 212         pll->in.refclk_dbler_en = 0;
 213         pll->in.vco_measure_time = 5;
 214         pll->in.kvco_measure_time = 5;
 215         pll->in.bandgap_timer = 4;
 216         pll->in.pll_wakeup_timer = 5;
 217         pll->in.plllock_cnt = 1;
 218         pll->in.plllock_rng = 0;
 219
 220         /*
 221          * SSC is enabled by default. We might need DT props for configuring
 222          * some SSC params like PPM and center/down spread etc.
 223          */
 224         pll->in.ssc_en = 1;
 225         pll->in.ssc_center = 0;         /* down spread by default */
 226         pll->in.ssc_spread = 5;         /* PPM / 1000 */
 227         pll->in.ssc_freq = 31500;       /* default recommended */
 228         pll->in.ssc_adj_period = 37;
 229
 230         pll->in.pll_ie_trim = 4;
 231         pll->in.pll_ip_trim = 4;
 232         pll->in.pll_cpcset_cur = 1;
 233         pll->in.pll_cpmset_cur = 1;
 234         pll->in.pll_icpmset = 4;
 235         pll->in.pll_icpcset = 4;
 236         pll->in.pll_icpmset_p = 0;
 237         pll->in.pll_icpmset_m = 0;
 238         pll->in.pll_icpcset_p = 0;
 239         pll->in.pll_icpcset_m = 0;
 240         pll->in.pll_lpf_res1 = 3;
 241         pll->in.pll_lpf_cap1 = 11;
 242         pll->in.pll_lpf_cap2 = 1;
 243         pll->in.pll_iptat_trim = 7;
 244         pll->in.pll_c3ctrl = 2;
 245         pll->in.pll_r3ctrl = 1;
 246 }
 247
 248 #define CEIL(x, y)              (((x) + ((y) - 1)) / (y))
 249
 250 static void pll_14nm_ssc_calc(struct dsi_pll_14nm *pll)
 251 {
 252         u32 period, ssc_period;
 253         u32 ref, rem;
 254         u64 step_size;
 255
 256         DBG("vco=%lld ref=%lld", pll->vco_current_rate, pll->vco_ref_clk_rate);
 257
 258         ssc_period = pll->in.ssc_freq / 500;
 259         period = (u32)pll->vco_ref_clk_rate / 1000;
 260         ssc_period  = CEIL(period, ssc_period);
 261         ssc_period -= 1;
 262         pll->out.ssc_period = ssc_period;
 263
 264         DBG("ssc freq=%d spread=%d period=%d", pll->in.ssc_freq,
 265             pll->in.ssc_spread, pll->out.ssc_period);
 266
 267         step_size = (u32)pll->vco_current_rate;
 268         ref = pll->vco_ref_clk_rate;
 269         ref /= 1000;
 270         step_size = div_u64(step_size, ref);
 271         step_size <<= 20;
 272         step_size = div_u64(step_size, 1000);
 273         step_size *= pll->in.ssc_spread;
 274         step_size = div_u64(step_size, 1000);
 275         step_size *= (pll->in.ssc_adj_period + 1);
 276
 277         rem = 0;
 278         step_size = div_u64_rem(step_size, ssc_period + 1, &rem);
 279         if (rem)
 280                 step_size++;
 281
 282         DBG("step_size=%lld", step_size);
 283
 284         step_size &= 0x0ffff;   /* take lower 16 bits */
 285
 286         pll->out.ssc_step_size = step_size;
 287 }
 288
 289 static void pll_14nm_dec_frac_calc(struct dsi_pll_14nm *pll)
 290 {
 291         struct dsi_pll_input *pin = &pll->in;
 292         struct dsi_pll_output *pout = &pll->out;
 293         u64 multiplier = BIT(20);
 294         u64 dec_start_multiple, dec_start, pll_comp_val;
 295         u32 duration, div_frac_start;
 296         u64 vco_clk_rate = pll->vco_current_rate;
 297         u64 fref = pll->vco_ref_clk_rate;
 298
 299         DBG("vco_clk_rate=%lld ref_clk_rate=%lld", vco_clk_rate, fref);
 300
 301         dec_start_multiple = div_u64(vco_clk_rate * multiplier, fref);
 302         div_u64_rem(dec_start_multiple, multiplier, &div_frac_start);
 303
 304         dec_start = div_u64(dec_start_multiple, multiplier);
 305
 306         pout->dec_start = (u32)dec_start;
 307         pout->div_frac_start = div_frac_start;
 308
 309         if (pin->plllock_cnt == 0)
 310                 duration = 1024;
 311         else if (pin->plllock_cnt == 1)
 312                 duration = 256;
 313         else if (pin->plllock_cnt == 2)
 314                 duration = 128;
 315         else
 316                 duration = 32;
 317
 318         pll_comp_val = duration * dec_start_multiple;
 319         pll_comp_val = div_u64(pll_comp_val, multiplier);
 320         do_div(pll_comp_val, 10);
 321
 322         pout->plllock_cmp = (u32)pll_comp_val;
 323
 324         pout->pll_txclk_en = 1;
 325         pout->cmn_ldo_cntrl = 0x3c;
 326 }
 327
 328 static u32 pll_14nm_kvco_slop(u32 vrate)
 329 {
 330         u32 slop = 0;
 331
 332         if (vrate > VCO_MIN_RATE && vrate <= 1800000000UL)
 333                 slop =  600;
 334         else if (vrate > 1800000000UL && vrate < 2300000000UL)
 335                 slop = 400;
 336         else if (vrate > 2300000000UL && vrate < VCO_MAX_RATE)
 337                 slop = 280;
 338
 339         return slop;
 340 }
 341
 342 static void pll_14nm_calc_vco_count(struct dsi_pll_14nm *pll)
 343 {
 344         struct dsi_pll_input *pin = &pll->in;
 345         struct dsi_pll_output *pout = &pll->out;
 346         u64 vco_clk_rate = pll->vco_current_rate;
 347         u64 fref = pll->vco_ref_clk_rate;
 348         u64 data;
 349         u32 cnt;
 350
 351         data = fref * pin->vco_measure_time;
 352         do_div(data, 1000000);
 353         data &= 0x03ff; /* 10 bits */
 354         data -= 2;
 355         pout->pll_vco_div_ref = data;
 356
 357         data = div_u64(vco_clk_rate, 1000000);  /* unit is Mhz */
 358         data *= pin->vco_measure_time;
 359         do_div(data, 10);
 360         pout->pll_vco_count = data;
 361
 362         data = fref * pin->kvco_measure_time;
 363         do_div(data, 1000000);
 364         data &= 0x03ff; /* 10 bits */
 365         data -= 1;
 366         pout->pll_kvco_div_ref = data;
 367
 368         cnt = pll_14nm_kvco_slop(vco_clk_rate);
 369         cnt *= 2;
 370         cnt /= 100;
 371         cnt *= pin->kvco_measure_time;
 372         pout->pll_kvco_count = cnt;
 373
 374         pout->pll_misc1 = 16;
 375         pout->pll_resetsm_cntrl = 48;
 376         pout->pll_resetsm_cntrl2 = pin->bandgap_timer << 3;
 377         pout->pll_resetsm_cntrl5 = pin->pll_wakeup_timer;
 378         pout->pll_kvco_code = 0;
 379 }
 380
 381 static void pll_db_commit_ssc(struct dsi_pll_14nm *pll)
 382 {
 383         void __iomem *base = pll->mmio;
 384         struct dsi_pll_input *pin = &pll->in;
 385         struct dsi_pll_output *pout = &pll->out;
 386         u8 data;
 387
 388         data = pin->ssc_adj_period;
 389         data &= 0x0ff;
 390         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_ADJ_PER1, data);
 391         data = (pin->ssc_adj_period >> 8);
 392         data &= 0x03;
 393         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_ADJ_PER2, data);
 394
 395         data = pout->ssc_period;
 396         data &= 0x0ff;
 397         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_PER1, data);
 398         data = (pout->ssc_period >> 8);
 399         data &= 0x0ff;
 400         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_PER2, data);
 401
 402         data = pout->ssc_step_size;
 403         data &= 0x0ff;
 404         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_STEP_SIZE1, data);
 405         data = (pout->ssc_step_size >> 8);
 406         data &= 0x0ff;
 407         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_STEP_SIZE2, data);
 408
 409         data = (pin->ssc_center & 0x01);
 410         data <<= 1;
 411         data |= 0x01; /* enable */
 412         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SSC_EN_CENTER, data);
 413
 414         wmb();  /* make sure register committed */
 415 }
 416
 417 static void pll_db_commit_common(struct dsi_pll_14nm *pll,
 418                                  struct dsi_pll_input *pin,
 419                                  struct dsi_pll_output *pout)
 420 {
 421         void __iomem *base = pll->mmio;
 422         u8 data;
 423
 424         /* confgiure the non frequency dependent pll registers */
 425         data = 0;
 426         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_SYSCLK_EN_RESET, data);
 427
 428         data = pout->pll_txclk_en;
 429         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_TXCLK_EN, data);
 430
 431         data = pout->pll_resetsm_cntrl;
 432         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_RESETSM_CNTRL, data);
 433         data = pout->pll_resetsm_cntrl2;
 434         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_RESETSM_CNTRL2, data);
 435         data = pout->pll_resetsm_cntrl5;
 436         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_RESETSM_CNTRL5, data);
 437
 438         data = pout->pll_vco_div_ref & 0xff;
 439         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_VCO_DIV_REF1, data);
 440         data = (pout->pll_vco_div_ref >> 8) & 0x3;
 441         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_VCO_DIV_REF2, data);
 442
 443         data = pout->pll_kvco_div_ref & 0xff;
 444         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_KVCO_DIV_REF1, data);
 445         data = (pout->pll_kvco_div_ref >> 8) & 0x3;
 446         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_KVCO_DIV_REF2, data);
 447
 448         data = pout->pll_misc1;
 449         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_MISC1, data);
 450
 451         data = pin->pll_ie_trim;
 452         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_IE_TRIM, data);
 453
 454         data = pin->pll_ip_trim;
 455         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_IP_TRIM, data);
 456
 457         data = pin->pll_cpmset_cur << 3 | pin->pll_cpcset_cur;
 458         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_CP_SET_CUR, data);
 459
 460         data = pin->pll_icpcset_p << 3 | pin->pll_icpcset_m;
 461         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_ICPCSET, data);
 462
 463         data = pin->pll_icpmset_p << 3 | pin->pll_icpcset_m;
 464         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_ICPMSET, data);
 465
 466         data = pin->pll_icpmset << 3 | pin->pll_icpcset;
 467         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_ICP_SET, data);
 468
 469         data = pin->pll_lpf_cap2 << 4 | pin->pll_lpf_cap1;
 470         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_LPF1, data);
 471
 472         data = pin->pll_iptat_trim;
 473         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_IPTAT_TRIM, data);
 474
 475         data = pin->pll_c3ctrl | pin->pll_r3ctrl << 4;
 476         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_CRCTRL, data);
 477 }
 478
 479 static void pll_14nm_software_reset(struct dsi_pll_14nm *pll_14nm)
 480 {
 481         void __iomem *cmn_base = pll_14nm->phy_cmn_mmio;
 482
 483         /* de assert pll start and apply pll sw reset */
 484
 485         /* stop pll */
 486         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_PLL_CNTRL, 0);
 487
 488         /* pll sw reset */
 489         dsi_phy_write_udelay(cmn_base + REG_DSI_14nm_PHY_CMN_CTRL_1, 0x20, 10);
 490         wmb();  /* make sure register committed */
 491
 492         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_CTRL_1, 0);
 493         wmb();  /* make sure register committed */
 494 }
 495
 496 static void pll_db_commit_14nm(struct dsi_pll_14nm *pll,
 497                                struct dsi_pll_input *pin,
 498                                struct dsi_pll_output *pout)
 499 {
 500         void __iomem *base = pll->mmio;
 501         void __iomem *cmn_base = pll->phy_cmn_mmio;
 502         u8 data;
 503
 504         DBG("DSI%d PLL", pll->id);
 505
 506         data = pout->cmn_ldo_cntrl;
 507         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_LDO_CNTRL, data);
 508
 509         pll_db_commit_common(pll, pin, pout);
 510
 511         pll_14nm_software_reset(pll);
 512
 513         data = pin->dsiclk_sel; /* set dsiclk_sel = 1  */
 514         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_CLK_CFG1, data);
 515
 516         data = 0xff; /* data, clk, pll normal operation */
 517         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_CTRL_0, data);
 518
 519         /* configure the frequency dependent pll registers */
 520         data = pout->dec_start;
 521         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_DEC_START, data);
 522
 523         data = pout->div_frac_start & 0xff;
 524         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_DIV_FRAC_START1, data);
 525         data = (pout->div_frac_start >> 8) & 0xff;
 526         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_DIV_FRAC_START2, data);
 527         data = (pout->div_frac_start >> 16) & 0xf;
 528         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_DIV_FRAC_START3, data);
 529
 530         data = pout->plllock_cmp & 0xff;
 531         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLLLOCK_CMP1, data);
 532
 533         data = (pout->plllock_cmp >> 8) & 0xff;
 534         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLLLOCK_CMP2, data);
 535
 536         data = (pout->plllock_cmp >> 16) & 0x3;
 537         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLLLOCK_CMP3, data);
 538
 539         data = pin->plllock_cnt << 1 | pin->plllock_rng << 3;
 540         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLLLOCK_CMP_EN, data);
 541
 542         data = pout->pll_vco_count & 0xff;
 543         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_VCO_COUNT1, data);
 544         data = (pout->pll_vco_count >> 8) & 0xff;
 545         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_VCO_COUNT2, data);
 546
 547         data = pout->pll_kvco_count & 0xff;
 548         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_KVCO_COUNT1, data);
 549         data = (pout->pll_kvco_count >> 8) & 0x3;
 550         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_KVCO_COUNT2, data);
 551
 552         data = (pout->pll_postdiv - 1) << 4 | pin->pll_lpf_res1;
 553         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_LPF2_POSTDIV, data);
 554
 555         if (pin->ssc_en)
 556                 pll_db_commit_ssc(pll);
 557
 558         wmb();  /* make sure register committed */
 559 }
 560
 561 /*
 562  * VCO clock Callbacks
 563  */
 564 static int dsi_pll_14nm_vco_set_rate(struct clk_hw *hw, unsigned long rate,
 565                                      unsigned long parent_rate)
 566 {
 567         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(hw);
 568         struct dsi_pll_input *pin = &pll_14nm->in;
 569         struct dsi_pll_output *pout = &pll_14nm->out;
 570
 571         DBG("DSI PLL%d rate=%lu, parent's=%lu", pll_14nm->id, rate,
 572             parent_rate);
 573
 574         pll_14nm->vco_current_rate = rate;
 575         pll_14nm->vco_ref_clk_rate = VCO_REF_CLK_RATE;
 576
 577         dsi_pll_14nm_input_init(pll_14nm);
 578
 579         /*
 580          * This configures the post divider internal to the VCO. It's
 581          * fixed to divide by 1 for now.
 582          *
 583          * tx_band = pll_postdiv.
 584          * 0: divided by 1
 585          * 1: divided by 2
 586          * 2: divided by 4
 587          * 3: divided by 8
 588          */
 589         pout->pll_postdiv = DSI_PLL_DEFAULT_VCO_POSTDIV;
 590
 591         pll_14nm_dec_frac_calc(pll_14nm);
 592
 593         if (pin->ssc_en)
 594                 pll_14nm_ssc_calc(pll_14nm);
 595
 596         pll_14nm_calc_vco_count(pll_14nm);
 597
 598         /* commit the slave DSI PLL registers if we're master. Note that we
 599          * don't lock the slave PLL. We just ensure that the PLL/PHY registers
 600          * of the master and slave are identical
 601          */
 602         if (pll_14nm->phy->usecase == MSM_DSI_PHY_MASTER) {
 603                 struct dsi_pll_14nm *pll_14nm_slave = pll_14nm->slave;
 604
 605                 pll_db_commit_14nm(pll_14nm_slave, pin, pout);
 606         }
 607
 608         pll_db_commit_14nm(pll_14nm, pin, pout);
 609
 610         return 0;
 611 }
 612
 613 static unsigned long dsi_pll_14nm_vco_recalc_rate(struct clk_hw *hw,
 614                                                   unsigned long parent_rate)
 615 {
 616         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(hw);
 617         void __iomem *base = pll_14nm->mmio;
 618         u64 vco_rate, multiplier = BIT(20);
 619         u32 div_frac_start;
 620         u32 dec_start;
 621         u64 ref_clk = parent_rate;
 622
 623         dec_start = dsi_phy_read(base + REG_DSI_14nm_PHY_PLL_DEC_START);
 624         dec_start &= 0x0ff;
 625
 626         DBG("dec_start = %x", dec_start);
 627
 628         div_frac_start = (dsi_phy_read(base + REG_DSI_14nm_PHY_PLL_DIV_FRAC_START3)
 629                                 & 0xf) << 16;
 630         div_frac_start |= (dsi_phy_read(base + REG_DSI_14nm_PHY_PLL_DIV_FRAC_START2)
 631                                 & 0xff) << 8;
 632         div_frac_start |= dsi_phy_read(base + REG_DSI_14nm_PHY_PLL_DIV_FRAC_START1)
 633                                 & 0xff;
 634
 635         DBG("div_frac_start = %x", div_frac_start);
 636
 637         vco_rate = ref_clk * dec_start;
 638
 639         vco_rate += ((ref_clk * div_frac_start) / multiplier);
 640
 641         /*
 642          * Recalculating the rate from dec_start and frac_start doesn't end up
 643          * the rate we originally set. Convert the freq to KHz, round it up and
 644          * convert it back to MHz.
 645          */
 646         vco_rate = DIV_ROUND_UP_ULL(vco_rate, 1000) * 1000;
 647
 648         DBG("returning vco rate = %lu", (unsigned long)vco_rate);
 649
 650         return (unsigned long)vco_rate;
 651 }
 652
 653 static int dsi_pll_14nm_vco_prepare(struct clk_hw *hw)
 654 {
 655         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(hw);
 656         void __iomem *base = pll_14nm->mmio;
 657         void __iomem *cmn_base = pll_14nm->phy_cmn_mmio;
 658         bool locked;
 659
 660         DBG("");
 661
 662         if (unlikely(pll_14nm->phy->pll_on))
 663                 return 0;
 664
 665         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_VREF_CFG1, 0x10);
 666         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_PLL_CNTRL, 1);
 667
 668         locked = pll_14nm_poll_for_ready(pll_14nm, POLL_MAX_READS,
 669                                          POLL_TIMEOUT_US);
 670
 671         if (unlikely(!locked)) {
 672                 DRM_DEV_ERROR(&pll_14nm->pdev->dev, "DSI PLL lock failed\n");
 673                 return -EINVAL;
 674         }
 675
 676         DBG("DSI PLL lock success");
 677         pll_14nm->phy->pll_on = true;
 678
 679         return 0;
 680 }
 681
 682 static void dsi_pll_14nm_vco_unprepare(struct clk_hw *hw)
 683 {
 684         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(hw);
 685         void __iomem *cmn_base = pll_14nm->phy_cmn_mmio;
 686
 687         DBG("");
 688
 689         if (unlikely(!pll_14nm->phy->pll_on))
 690                 return;
 691
 692         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_PLL_CNTRL, 0);
 693
 694         pll_14nm->phy->pll_on = false;
 695 }
 696
 697 static long dsi_pll_14nm_clk_round_rate(struct clk_hw *hw,
 698                 unsigned long rate, unsigned long *parent_rate)
 699 {
 700         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(hw);
 701
 702         if      (rate < pll_14nm->phy->cfg->min_pll_rate)
 703                 return  pll_14nm->phy->cfg->min_pll_rate;
 704         else if (rate > pll_14nm->phy->cfg->max_pll_rate)
 705                 return  pll_14nm->phy->cfg->max_pll_rate;
 706         else
 707                 return rate;
 708 }
 709
 710 static const struct clk_ops clk_ops_dsi_pll_14nm_vco = {
 711         .round_rate = dsi_pll_14nm_clk_round_rate,
 712         .set_rate = dsi_pll_14nm_vco_set_rate,
 713         .recalc_rate = dsi_pll_14nm_vco_recalc_rate,
 714         .prepare = dsi_pll_14nm_vco_prepare,
 715         .unprepare = dsi_pll_14nm_vco_unprepare,
 716 };
 717
 718 /*
 719  * N1 and N2 post-divider clock callbacks
 720  */
 721 #define div_mask(width) ((1 << (width)) - 1)
 722 static unsigned long dsi_pll_14nm_postdiv_recalc_rate(struct clk_hw *hw,
 723                                                       unsigned long parent_rate)
 724 {
 725         struct dsi_pll_14nm_postdiv *postdiv = to_pll_14nm_postdiv(hw);
 726         struct dsi_pll_14nm *pll_14nm = postdiv->pll;
 727         void __iomem *base = pll_14nm->phy_cmn_mmio;
 728         u8 shift = postdiv->shift;
 729         u8 width = postdiv->width;
 730         u32 val;
 731
 732         DBG("DSI%d PLL parent rate=%lu", pll_14nm->id, parent_rate);
 733
 734         val = dsi_phy_read(base + REG_DSI_14nm_PHY_CMN_CLK_CFG0) >> shift;
 735         val &= div_mask(width);
 736
 737         return divider_recalc_rate(hw, parent_rate, val, NULL,
 738                                    postdiv->flags, width);
 739 }
 740
 741 static long dsi_pll_14nm_postdiv_round_rate(struct clk_hw *hw,
 742                                             unsigned long rate,
 743                                             unsigned long *prate)
 744 {
 745         struct dsi_pll_14nm_postdiv *postdiv = to_pll_14nm_postdiv(hw);
 746         struct dsi_pll_14nm *pll_14nm = postdiv->pll;
 747
 748         DBG("DSI%d PLL parent rate=%lu", pll_14nm->id, rate);
 749
 750         return divider_round_rate(hw, rate, prate, NULL,
 751                                   postdiv->width,
 752                                   postdiv->flags);
 753 }
 754
 755 static int dsi_pll_14nm_postdiv_set_rate(struct clk_hw *hw, unsigned long rate,
 756                                          unsigned long parent_rate)
 757 {
 758         struct dsi_pll_14nm_postdiv *postdiv = to_pll_14nm_postdiv(hw);
 759         struct dsi_pll_14nm *pll_14nm = postdiv->pll;
 760         void __iomem *base = pll_14nm->phy_cmn_mmio;
 761         spinlock_t *lock = &pll_14nm->postdiv_lock;
 762         u8 shift = postdiv->shift;
 763         u8 width = postdiv->width;
 764         unsigned int value;
 765         unsigned long flags = 0;
 766         u32 val;
 767
 768         DBG("DSI%d PLL parent rate=%lu parent rate %lu", pll_14nm->id, rate,
 769             parent_rate);
 770
 771         value = divider_get_val(rate, parent_rate, NULL, postdiv->width,
 772                                 postdiv->flags);
 773
 774         spin_lock_irqsave(lock, flags);
 775
 776         val = dsi_phy_read(base + REG_DSI_14nm_PHY_CMN_CLK_CFG0);
 777         val &= ~(div_mask(width) << shift);
 778
 779         val |= value << shift;
 780         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_CLK_CFG0, val);
 781
 782         /* If we're master in dual DSI mode, then the slave PLL's post-dividers
 783          * follow the master's post dividers
 784          */
 785         if (pll_14nm->phy->usecase == MSM_DSI_PHY_MASTER) {
 786                 struct dsi_pll_14nm *pll_14nm_slave = pll_14nm->slave;
 787                 void __iomem *slave_base = pll_14nm_slave->phy_cmn_mmio;
 788
 789                 dsi_phy_write(slave_base + REG_DSI_14nm_PHY_CMN_CLK_CFG0, val);
 790         }
 791
 792         spin_unlock_irqrestore(lock, flags);
 793
 794         return 0;
 795 }
 796
 797 static const struct clk_ops clk_ops_dsi_pll_14nm_postdiv = {
 798         .recalc_rate = dsi_pll_14nm_postdiv_recalc_rate,
 799         .round_rate = dsi_pll_14nm_postdiv_round_rate,
 800         .set_rate = dsi_pll_14nm_postdiv_set_rate,
 801 };
 802
 803 /*
 804  * PLL Callbacks
 805  */
 806
 807 static void dsi_14nm_pll_save_state(struct msm_dsi_phy *phy)
 808 {
 809         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(phy->vco_hw);
 810         struct pll_14nm_cached_state *cached_state = &pll_14nm->cached_state;
 811         void __iomem *cmn_base = pll_14nm->phy_cmn_mmio;
 812         u32 data;
 813
 814         data = dsi_phy_read(cmn_base + REG_DSI_14nm_PHY_CMN_CLK_CFG0);
 815
 816         cached_state->n1postdiv = data & 0xf;
 817         cached_state->n2postdiv = (data >> 4) & 0xf;
 818
 819         DBG("DSI%d PLL save state %x %x", pll_14nm->id,
 820             cached_state->n1postdiv, cached_state->n2postdiv);
 821
 822         cached_state->vco_rate = clk_hw_get_rate(phy->vco_hw);
 823 }
 824
 825 static int dsi_14nm_pll_restore_state(struct msm_dsi_phy *phy)
 826 {
 827         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(phy->vco_hw);
 828         struct pll_14nm_cached_state *cached_state = &pll_14nm->cached_state;
 829         void __iomem *cmn_base = pll_14nm->phy_cmn_mmio;
 830         u32 data;
 831         int ret;
 832
 833         ret = dsi_pll_14nm_vco_set_rate(phy->vco_hw,
 834                                         cached_state->vco_rate, 0);
 835         if (ret) {
 836                 DRM_DEV_ERROR(&pll_14nm->pdev->dev,
 837                         "restore vco rate failed. ret=%d\n", ret);
 838                 return ret;
 839         }
 840
 841         data = cached_state->n1postdiv | (cached_state->n2postdiv << 4);
 842
 843         DBG("DSI%d PLL restore state %x %x", pll_14nm->id,
 844             cached_state->n1postdiv, cached_state->n2postdiv);
 845
 846         dsi_phy_write(cmn_base + REG_DSI_14nm_PHY_CMN_CLK_CFG0, data);
 847
 848         /* also restore post-dividers for slave DSI PLL */
 849         if (phy->usecase == MSM_DSI_PHY_MASTER) {
 850                 struct dsi_pll_14nm *pll_14nm_slave = pll_14nm->slave;
 851                 void __iomem *slave_base = pll_14nm_slave->phy_cmn_mmio;
 852
 853                 dsi_phy_write(slave_base + REG_DSI_14nm_PHY_CMN_CLK_CFG0, data);
 854         }
 855
 856         return 0;
 857 }
 858
 859 static int dsi_14nm_set_usecase(struct msm_dsi_phy *phy)
 860 {
 861         struct dsi_pll_14nm *pll_14nm = to_pll_14nm(phy->vco_hw);
 862         void __iomem *base = pll_14nm->mmio;
 863         u32 clkbuflr_en, bandgap = 0;
 864
 865         switch (phy->usecase) {
 866         case MSM_DSI_PHY_STANDALONE:
 867                 clkbuflr_en = 0x1;
 868                 break;
 869         case MSM_DSI_PHY_MASTER:
 870                 clkbuflr_en = 0x3;
 871                 pll_14nm->slave = pll_14nm_list[(pll_14nm->id + 1) % DSI_MAX];
 872                 break;
 873         case MSM_DSI_PHY_SLAVE:
 874                 clkbuflr_en = 0x0;
 875                 bandgap = 0x3;
 876                 break;
 877         default:
 878                 return -EINVAL;
 879         }
 880
 881         dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_CLKBUFLR_EN, clkbuflr_en);
 882         if (bandgap)
 883                 dsi_phy_write(base + REG_DSI_14nm_PHY_PLL_PLL_BANDGAP, bandgap);
 884
 885         return 0;
 886 }
 887
 888 static struct clk_hw *pll_14nm_postdiv_register(struct dsi_pll_14nm *pll_14nm,
 889                                                 const char *name,
 890                                                 const char *parent_name,
 891                                                 unsigned long flags,
 892                                                 u8 shift)
 893 {
 894         struct dsi_pll_14nm_postdiv *pll_postdiv;
 895         struct device *dev = &pll_14nm->pdev->dev;
 896         struct clk_init_data postdiv_init = {
 897                 .parent_names = (const char *[]) { parent_name },
 898                 .num_parents = 1,
 899                 .name = name,
 900                 .flags = flags,
 901                 .ops = &clk_ops_dsi_pll_14nm_postdiv,
 902         };
 903         int ret;
 904
 905         pll_postdiv = devm_kzalloc(dev, sizeof(*pll_postdiv), GFP_KERNEL);
 906         if (!pll_postdiv)
 907                 return ERR_PTR(-ENOMEM);
 908
 909         pll_postdiv->pll = pll_14nm;
 910         pll_postdiv->shift = shift;
 911         /* both N1 and N2 postdividers are 4 bits wide */
 912         pll_postdiv->width = 4;
 913         /* range of each divider is from 1 to 15 */
 914         pll_postdiv->flags = CLK_DIVIDER_ONE_BASED;
 915         pll_postdiv->hw.init = &postdiv_init;
 916
 917         ret = devm_clk_hw_register(dev, &pll_postdiv->hw);
 918         if (ret)
 919                 return ERR_PTR(ret);
 920
 921         return &pll_postdiv->hw;
 922 }
 923
 924 static int pll_14nm_register(struct dsi_pll_14nm *pll_14nm, struct clk_hw **provided_clocks)
 925 {
 926         char clk_name[32], parent[32], vco_name[32];
 927         struct clk_init_data vco_init = {
 928                 .parent_names = (const char *[]){ "xo" },
 929                 .num_parents = 1,
 930                 .name = vco_name,
 931                 .flags = CLK_IGNORE_UNUSED,
 932                 .ops = &clk_ops_dsi_pll_14nm_vco,
 933         };
 934         struct device *dev = &pll_14nm->pdev->dev;
 935         struct clk_hw *hw;
 936         int ret;
 937
 938         DBG("DSI%d", pll_14nm->id);
 939
 940         snprintf(vco_name, 32, "dsi%dvco_clk", pll_14nm->id);
 941         pll_14nm->clk_hw.init = &vco_init;
 942
 943         ret = devm_clk_hw_register(dev, &pll_14nm->clk_hw);
 944         if (ret)
 945                 return ret;
 946
 947         snprintf(clk_name, 32, "dsi%dn1_postdiv_clk", pll_14nm->id);
 948         snprintf(parent, 32, "dsi%dvco_clk", pll_14nm->id);
 949
 950         /* N1 postdiv, bits 0-3 in REG_DSI_14nm_PHY_CMN_CLK_CFG0 */
 951         hw = pll_14nm_postdiv_register(pll_14nm, clk_name, parent,
 952                                        CLK_SET_RATE_PARENT, 0);
 953         if (IS_ERR(hw))
 954                 return PTR_ERR(hw);
 955
 956         snprintf(clk_name, 32, "dsi%dpllbyte", pll_14nm->id);
 957         snprintf(parent, 32, "dsi%dn1_postdiv_clk", pll_14nm->id);
 958
 959         /* DSI Byte clock = VCO_CLK / N1 / 8 */
 960         hw = devm_clk_hw_register_fixed_factor(dev, clk_name, parent,
 961                                           CLK_SET_RATE_PARENT, 1, 8);
 962         if (IS_ERR(hw))
 963                 return PTR_ERR(hw);
 964
 965         provided_clocks[DSI_BYTE_PLL_CLK] = hw;
 966
 967         snprintf(clk_name, 32, "dsi%dn1_postdivby2_clk", pll_14nm->id);
 968         snprintf(parent, 32, "dsi%dn1_postdiv_clk", pll_14nm->id);
 969
 970         /*
 971          * Skip the mux for now, force DSICLK_SEL to 1, Add a /2 divider
 972          * on the way. Don't let it set parent.
 973          */
 974         hw = devm_clk_hw_register_fixed_factor(dev, clk_name, parent, 0, 1, 2);
 975         if (IS_ERR(hw))
 976                 return PTR_ERR(hw);
 977
 978         snprintf(clk_name, 32, "dsi%dpll", pll_14nm->id);
 979         snprintf(parent, 32, "dsi%dn1_postdivby2_clk", pll_14nm->id);
 980
 981         /* DSI pixel clock = VCO_CLK / N1 / 2 / N2
 982          * This is the output of N2 post-divider, bits 4-7 in
 983          * REG_DSI_14nm_PHY_CMN_CLK_CFG0. Don't let it set parent.
 984          */
 985         hw = pll_14nm_postdiv_register(pll_14nm, clk_name, parent, 0, 4);
 986         if (IS_ERR(hw))
 987                 return PTR_ERR(hw);
 988
 989         provided_clocks[DSI_PIXEL_PLL_CLK]      = hw;
 990
 991         return 0;
 992 }
 993
 994 static int dsi_pll_14nm_init(struct msm_dsi_phy *phy)
 995 {
 996         struct platform_device *pdev = phy->pdev;
 997         int id = phy->id;
 998         struct dsi_pll_14nm *pll_14nm;
 999         int ret;
1000
1001         if (!pdev)
1002                 return -ENODEV;
1003
1004         pll_14nm = devm_kzalloc(&pdev->dev, sizeof(*pll_14nm), GFP_KERNEL);
1005         if (!pll_14nm)
1006                 return -ENOMEM;
1007
1008         DBG("PLL%d", id);
1009
1010         pll_14nm->pdev = pdev;
1011         pll_14nm->id = id;
1012         pll_14nm_list[id] = pll_14nm;
1013
1014         pll_14nm->phy_cmn_mmio = msm_ioremap(pdev, "dsi_phy", "DSI_PHY");
1015         if (IS_ERR_OR_NULL(pll_14nm->phy_cmn_mmio)) {
1016                 DRM_DEV_ERROR(&pdev->dev, "failed to map CMN PHY base\n");
1017                 return -ENOMEM;
1018         }
1019
1020         pll_14nm->mmio = msm_ioremap(pdev, "dsi_pll", "DSI_PLL");
1021         if (IS_ERR_OR_NULL(pll_14nm->mmio)) {
1022                 DRM_DEV_ERROR(&pdev->dev, "failed to map PLL base\n");
1023                 return -ENOMEM;
1024         }
1025
1026         spin_lock_init(&pll_14nm->postdiv_lock);
1027
1028         pll_14nm->phy = phy;
1029
1030         ret = pll_14nm_register(pll_14nm, phy->provided_clocks->hws);
1031         if (ret) {
1032                 DRM_DEV_ERROR(&pdev->dev, "failed to register PLL: %d\n", ret);
1033                 return ret;
1034         }
1035
1036         phy->vco_hw = &pll_14nm->clk_hw;
1037
1038         return 0;
1039 }
1040
1041 static void dsi_14nm_dphy_set_timing(struct msm_dsi_phy *phy,
1042                                      struct msm_dsi_dphy_timing *timing,
1043                                      int lane_idx)
1044 {
1045         void __iomem *base = phy->lane_base;
1046         bool clk_ln = (lane_idx == PHY_14NM_CKLN_IDX);
1047         u32 zero = clk_ln ? timing->clk_zero : timing->hs_zero;
1048         u32 prepare = clk_ln ? timing->clk_prepare : timing->hs_prepare;
1049         u32 trail = clk_ln ? timing->clk_trail : timing->hs_trail;
1050         u32 rqst = clk_ln ? timing->hs_rqst_ckln : timing->hs_rqst;
1051         u32 prep_dly = clk_ln ? timing->hs_prep_dly_ckln : timing->hs_prep_dly;
1052         u32 halfbyte_en = clk_ln ? timing->hs_halfbyte_en_ckln :
1053                                    timing->hs_halfbyte_en;
1054
1055         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_4(lane_idx),
1056                       DSI_14nm_PHY_LN_TIMING_CTRL_4_HS_EXIT(timing->hs_exit));
1057         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_5(lane_idx),
1058                       DSI_14nm_PHY_LN_TIMING_CTRL_5_HS_ZERO(zero));
1059         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_6(lane_idx),
1060                       DSI_14nm_PHY_LN_TIMING_CTRL_6_HS_PREPARE(prepare));
1061         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_7(lane_idx),
1062                       DSI_14nm_PHY_LN_TIMING_CTRL_7_HS_TRAIL(trail));
1063         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_8(lane_idx),
1064                       DSI_14nm_PHY_LN_TIMING_CTRL_8_HS_RQST(rqst));
1065         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_CFG0(lane_idx),
1066                       DSI_14nm_PHY_LN_CFG0_PREPARE_DLY(prep_dly));
1067         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_CFG1(lane_idx),
1068                       halfbyte_en ? DSI_14nm_PHY_LN_CFG1_HALFBYTECLK_EN : 0);
1069         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_9(lane_idx),
1070                       DSI_14nm_PHY_LN_TIMING_CTRL_9_TA_GO(timing->ta_go) |
1071                       DSI_14nm_PHY_LN_TIMING_CTRL_9_TA_SURE(timing->ta_sure));
1072         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_10(lane_idx),
1073                       DSI_14nm_PHY_LN_TIMING_CTRL_10_TA_GET(timing->ta_get));
1074         dsi_phy_write(base + REG_DSI_14nm_PHY_LN_TIMING_CTRL_11(lane_idx),
1075                       DSI_14nm_PHY_LN_TIMING_CTRL_11_TRIG3_CMD(0xa0));
1076 }
1077
1078 static int dsi_14nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id,
1079                                struct msm_dsi_phy_clk_request *clk_req)
1080 {
1081         struct msm_dsi_dphy_timing *timing = &phy->timing;
1082         u32 data;
1083         int i;
1084         int ret;
1085         void __iomem *base = phy->base;
1086         void __iomem *lane_base = phy->lane_base;
1087
1088         if (msm_dsi_dphy_timing_calc_v2(timing, clk_req)) {
1089                 DRM_DEV_ERROR(&phy->pdev->dev,
1090                         "%s: D-PHY timing calculation failed\n", __func__);
1091                 return -EINVAL;
1092         }
1093
1094         data = 0x1c;
1095         if (phy->usecase != MSM_DSI_PHY_STANDALONE)
1096                 data |= DSI_14nm_PHY_CMN_LDO_CNTRL_VREG_CTRL(32);
1097         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_LDO_CNTRL, data);
1098
1099         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_GLBL_TEST_CTRL, 0x1);
1100
1101         /* 4 data lanes + 1 clk lane configuration */
1102         for (i = 0; i < 5; i++) {
1103                 dsi_phy_write(lane_base + REG_DSI_14nm_PHY_LN_VREG_CNTRL(i),
1104                               0x1d);
1105
1106                 dsi_phy_write(lane_base +
1107                               REG_DSI_14nm_PHY_LN_STRENGTH_CTRL_0(i), 0xff);
1108                 dsi_phy_write(lane_base +
1109                               REG_DSI_14nm_PHY_LN_STRENGTH_CTRL_1(i),
1110                               (i == PHY_14NM_CKLN_IDX) ? 0x00 : 0x06);
1111
1112                 dsi_phy_write(lane_base + REG_DSI_14nm_PHY_LN_CFG3(i),
1113                               (i == PHY_14NM_CKLN_IDX) ? 0x8f : 0x0f);
1114                 dsi_phy_write(lane_base + REG_DSI_14nm_PHY_LN_CFG2(i), 0x10);
1115                 dsi_phy_write(lane_base + REG_DSI_14nm_PHY_LN_TEST_DATAPATH(i),
1116                               0);
1117                 dsi_phy_write(lane_base + REG_DSI_14nm_PHY_LN_TEST_STR(i),
1118                               0x88);
1119
1120                 dsi_14nm_dphy_set_timing(phy, timing, i);
1121         }
1122
1123         /* Make sure PLL is not start */
1124         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_PLL_CNTRL, 0x00);
1125
1126         wmb(); /* make sure everything is written before reset and enable */
1127
1128         /* reset digital block */
1129         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_CTRL_1, 0x80);
1130         wmb(); /* ensure reset is asserted */
1131         udelay(100);
1132         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_CTRL_1, 0x00);
1133
1134         msm_dsi_phy_set_src_pll(phy, src_pll_id,
1135                                 REG_DSI_14nm_PHY_CMN_GLBL_TEST_CTRL,
1136                                 DSI_14nm_PHY_CMN_GLBL_TEST_CTRL_BITCLK_HS_SEL);
1137
1138         ret = dsi_14nm_set_usecase(phy);
1139         if (ret) {
1140                 DRM_DEV_ERROR(&phy->pdev->dev, "%s: set pll usecase failed, %d\n",
1141                         __func__, ret);
1142                 return ret;
1143         }
1144
1145         /* Remove power down from PLL and all lanes */
1146         dsi_phy_write(base + REG_DSI_14nm_PHY_CMN_CTRL_0, 0xff);
1147
1148         return 0;
1149 }
1150
1151 static void dsi_14nm_phy_disable(struct msm_dsi_phy *phy)
1152 {
1153         dsi_phy_write(phy->base + REG_DSI_14nm_PHY_CMN_GLBL_TEST_CTRL, 0);
1154         dsi_phy_write(phy->base + REG_DSI_14nm_PHY_CMN_CTRL_0, 0);
1155
1156         /* ensure that the phy is completely disabled */
1157         wmb();
1158 }
1159
1160 const struct msm_dsi_phy_cfg dsi_phy_14nm_cfgs = {
1161         .src_pll_truthtable = { {false, false}, {true, false} },
1162         .has_phy_lane = true,
1163         .reg_cfg = {
1164                 .num = 1,
1165                 .regs = {
1166                         {"vcca", 17000, 32},
1167                 },
1168         },
1169         .ops = {
1170                 .enable = dsi_14nm_phy_enable,
1171                 .disable = dsi_14nm_phy_disable,
1172                 .pll_init = dsi_pll_14nm_init,
1173                 .save_pll_state = dsi_14nm_pll_save_state,
1174                 .restore_pll_state = dsi_14nm_pll_restore_state,
1175         },
1176         .min_pll_rate = VCO_MIN_RATE,
1177         .max_pll_rate = VCO_MAX_RATE,
1178         .io_start = { 0x994400, 0x996400 },
1179         .num_dsi_phy = 2,
1180 };
1181
1182 const struct msm_dsi_phy_cfg dsi_phy_14nm_660_cfgs = {
1183         .src_pll_truthtable = { {false, false}, {true, false} },
1184         .has_phy_lane = true,
1185         .reg_cfg = {
1186                 .num = 1,
1187                 .regs = {
1188                         {"vcca", 17000, 32},
1189                 },
1190         },
1191         .ops = {
1192                 .enable = dsi_14nm_phy_enable,
1193                 .disable = dsi_14nm_phy_disable,
1194                 .pll_init = dsi_pll_14nm_init,
1195                 .save_pll_state = dsi_14nm_pll_save_state,
1196                 .restore_pll_state = dsi_14nm_pll_restore_state,
1197         },
1198         .min_pll_rate = VCO_MIN_RATE,
1199         .max_pll_rate = VCO_MAX_RATE,
1200         .io_start = { 0xc994400, 0xc996000 },
1201         .num_dsi_phy = 2,
1202 };