drivers/phy/phy-rockchip-inno-mipi-dphy.c

   1 /*
   2  * Copyright (c) 2017 Rockchip Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/delay.h>
  16 #include <linux/init.h>
  17 #include <linux/io.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/phy/phy.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regmap.h>
  23 #include <linux/reset.h>
  24
  25 #include <drm/drm_mipi_dsi.h>
  26
  27 #include <video/mipi_display.h>
  28 #include <video/of_videomode.h>
  29 #include <video/videomode.h>
  30
  31 #define DRV_NAME        "inno-mipi-dphy"
  32
  33 #define INNO_PHY_LANE_CTRL      0x00000
  34 #define INNO_PHY_POWER_CTRL     0x00004
  35 #define INNO_PHY_PLL_CTRL_0     0x0000c
  36 #define INNO_PHY_PLL_CTRL_1     0x00010
  37 #define INNO_PHY_DIG_CTRL       0x00080
  38 #define INNO_PHY_PIN_CTRL       0x00084
  39
  40 #define INNO_CLOCK_LANE_REG_BASE        0x00100
  41 #define INNO_DATA_LANE_0_REG_BASE       0x00180
  42 #define INNO_DATA_LANE_1_REG_BASE       0x00200
  43 #define INNO_DATA_LANE_2_REG_BASE       0x00280
  44 #define INNO_DATA_LANE_3_REG_BASE       0x00300
  45
  46 #define T_LPX_OFFSET            0x00014
  47 #define T_HS_PREPARE_OFFSET     0x00018
  48 #define T_HS_ZERO_OFFSET        0x0001c
  49 #define T_HS_TRAIL_OFFSET       0x00020
  50 #define T_HS_EXIT_OFFSET        0x00024
  51 #define T_CLK_POST_OFFSET       0x00028
  52 #define T_WAKUP_H_OFFSET        0x00030
  53 #define T_WAKUP_L_OFFSET        0x00034
  54 #define T_CLK_PRE_OFFSET        0x00038
  55 #define T_TA_GO_OFFSET          0x00040
  56 #define T_TA_SURE_OFFSET        0x00044
  57 #define T_TA_WAIT_OFFSET        0x00048
  58
  59 /* INNO_PHY_LANE_CTRL */
  60 #define M_CLK_LANE_EN           BIT(6)
  61 #define M_DATA_LANE_3_EN        BIT(5)
  62 #define M_DATA_LANE_2_EN        BIT(4)
  63 #define M_DATA_LANE_1_EN        BIT(3)
  64 #define M_DATA_LANE_0_EN        BIT(2)
  65 #define V_CLK_LANE_EN           BIT(6)
  66 #define V_DATA_LANE_3_EN        BIT(5)
  67 #define V_DATA_LANE_2_EN        BIT(4)
  68 #define V_DATA_LANE_1_EN        BIT(3)
  69 #define V_DATA_LANE_0_EN        BIT(2)
  70 /* INNO_PHY_PLL_CTRL_0 */
  71 #define M_FBDIV_8               BIT(5)
  72 #define M_PREDIV                (0x1f << 0)
  73 #define V_FBDIV_8(x)            ((x) << 5)
  74 #define V_PREDIV(x)             ((x) << 0)
  75 /* INNO_PHY_PLL_CTRL_1 */
  76 #define M_FBDIV_7_0             (0xff << 0)
  77 #define V_FBDIV_7_0(x)          ((x) << 0)
  78
  79 #define M_T_LPX                 (0x3f << 0)
  80 #define V_T_LPX(x)              ((x) << 0)
  81 #define M_T_HS_PREPARE          (0x7f << 0)
  82 #define V_T_HS_PREPARE(x)       ((x) << 0)
  83 #define M_T_HS_ZERO             (0x3f << 0)
  84 #define V_T_HS_ZERO(x)          ((x) << 0)
  85 #define M_T_HS_TRAIL            (0x7f << 0)
  86 #define V_T_HS_TRAIL(x)         ((x) << 0)
  87 #define M_T_HS_EXIT             (0x1f << 0)
  88 #define V_T_HS_EXIT(x)          ((x) << 0)
  89 #define M_T_CLK_POST            (0xf << 0)
  90 #define V_T_CLK_POST(x)         ((x) << 0)
  91 #define M_T_WAKUP_H             (0x3 << 0)
  92 #define V_T_WAKUP_H(x)          ((x) << 0)
  93 #define M_T_WAKUP_L             (0xff << 0)
  94 #define V_T_WAKUP_L(x)          ((x) << 0)
  95 #define M_T_CLK_PRE             (0xf << 0)
  96 #define V_T_CLK_PRE(x)          ((x) << 0)
  97 #define M_T_TA_GO               (0x3f << 0)
  98 #define V_T_TA_GO(x)            ((x) << 0)
  99 #define M_T_TA_SURE             (0x3f << 0)
 100 #define V_T_TA_SURE(x)          ((x) << 0)
 101 #define M_T_TA_WAIT             (0x3f << 0)
 102 #define V_T_TA_WAIT(x)          ((x) << 0)
 103
 104 enum lane_type {
 105         CLOCK_LANE,
 106         DATA_LANE_0,
 107         DATA_LANE_1,
 108         DATA_LANE_2,
 109         DATA_LANE_3,
 110 };
 111
 112 static const u32 lane_reg_offset[] = {
 113         [CLOCK_LANE] = INNO_CLOCK_LANE_REG_BASE,
 114         [DATA_LANE_0] = INNO_DATA_LANE_0_REG_BASE,
 115         [DATA_LANE_1] = INNO_DATA_LANE_1_REG_BASE,
 116         [DATA_LANE_2] = INNO_DATA_LANE_2_REG_BASE,
 117         [DATA_LANE_3] = INNO_DATA_LANE_3_REG_BASE,
 118 };
 119
 120 enum hs_clk_range {
 121         HS_CLK_RANGE_80_110_MHZ,
 122         HS_CLK_RANGE_110_150_MHZ,
 123         HS_CLK_RANGE_150_200_MHZ,
 124         HS_CLK_RANGE_200_250_MHZ,
 125         HS_CLK_RANGE_250_300_MHZ,
 126         HS_CLK_RANGE_300_400_MHZ,
 127         HS_CLK_RANGE_400_500_MHZ,
 128         HS_CLK_RANGE_500_600_MHZ,
 129         HS_CLK_RANGE_600_700_MHZ,
 130         HS_CLK_RANGE_700_800_MHZ,
 131         HS_CLK_RANGE_800_1000_MHZ,
 132 };
 133
 134 static const u8 t_hs_prepare_val[] = {
 135         [HS_CLK_RANGE_80_110_MHZ] = 0x20,
 136         [HS_CLK_RANGE_110_150_MHZ] = 0x06,
 137         [HS_CLK_RANGE_150_200_MHZ] = 0x18,
 138         [HS_CLK_RANGE_200_250_MHZ] = 0x05,
 139         [HS_CLK_RANGE_250_300_MHZ] = 0x51,
 140         [HS_CLK_RANGE_300_400_MHZ] = 0x64,
 141         [HS_CLK_RANGE_400_500_MHZ] = 0x20,
 142         [HS_CLK_RANGE_500_600_MHZ] = 0x6a,
 143         [HS_CLK_RANGE_600_700_MHZ] = 0x3e,
 144         [HS_CLK_RANGE_700_800_MHZ] = 0x21,
 145         [HS_CLK_RANGE_800_1000_MHZ] = 0x09,
 146 };
 147
 148 static const u8 clock_lane_t_hs_zero_val[] = {
 149         [HS_CLK_RANGE_80_110_MHZ] = 0x16,
 150         [HS_CLK_RANGE_110_150_MHZ] = 0x16,
 151         [HS_CLK_RANGE_150_200_MHZ] = 0x17,
 152         [HS_CLK_RANGE_200_250_MHZ] = 0x17,
 153         [HS_CLK_RANGE_250_300_MHZ] = 0x18,
 154         [HS_CLK_RANGE_300_400_MHZ] = 0x19,
 155         [HS_CLK_RANGE_400_500_MHZ] = 0x1b,
 156         [HS_CLK_RANGE_500_600_MHZ] = 0x1d,
 157         [HS_CLK_RANGE_600_700_MHZ] = 0x1e,
 158         [HS_CLK_RANGE_700_800_MHZ] = 0x1f,
 159         [HS_CLK_RANGE_800_1000_MHZ] = 0x20,
 160 };
 161
 162 static const u8 data_lane_t_hs_zero_val[] = {
 163         [HS_CLK_RANGE_80_110_MHZ] = 2,
 164         [HS_CLK_RANGE_110_150_MHZ] = 3,
 165         [HS_CLK_RANGE_150_200_MHZ] = 4,
 166         [HS_CLK_RANGE_200_250_MHZ] = 5,
 167         [HS_CLK_RANGE_250_300_MHZ] = 6,
 168         [HS_CLK_RANGE_300_400_MHZ] = 7,
 169         [HS_CLK_RANGE_400_500_MHZ] = 7,
 170         [HS_CLK_RANGE_500_600_MHZ] = 8,
 171         [HS_CLK_RANGE_600_700_MHZ] = 8,
 172         [HS_CLK_RANGE_700_800_MHZ] = 9,
 173         [HS_CLK_RANGE_800_1000_MHZ] = 9,
 174 };
 175
 176 static const u8 t_hs_trail_val[] = {
 177         [HS_CLK_RANGE_80_110_MHZ] = 0x22,
 178         [HS_CLK_RANGE_110_150_MHZ] = 0x45,
 179         [HS_CLK_RANGE_150_200_MHZ] = 0x0b,
 180         [HS_CLK_RANGE_200_250_MHZ] = 0x16,
 181         [HS_CLK_RANGE_250_300_MHZ] = 0x2c,
 182         [HS_CLK_RANGE_300_400_MHZ] = 0x33,
 183         [HS_CLK_RANGE_400_500_MHZ] = 0x4e,
 184         [HS_CLK_RANGE_500_600_MHZ] = 0x3a,
 185         [HS_CLK_RANGE_600_700_MHZ] = 0x6a,
 186         [HS_CLK_RANGE_700_800_MHZ] = 0x29,
 187         [HS_CLK_RANGE_800_1000_MHZ] = 0x27,
 188 };
 189
 190 struct mipi_dphy_timing {
 191         unsigned int clkmiss;
 192         unsigned int clkpost;
 193         unsigned int clkpre;
 194         unsigned int clkprepare;
 195         unsigned int clksettle;
 196         unsigned int clktermen;
 197         unsigned int clktrail;
 198         unsigned int clkzero;
 199         unsigned int dtermen;
 200         unsigned int eot;
 201         unsigned int hsexit;
 202         unsigned int hsprepare;
 203         unsigned int hszero;
 204         unsigned int hssettle;
 205         unsigned int hsskip;
 206         unsigned int hstrail;
 207         unsigned int init;
 208         unsigned int lpx;
 209         unsigned int taget;
 210         unsigned int tago;
 211         unsigned int tasure;
 212         unsigned int wakeup;
 213 };
 214
 215 struct inno_mipi_dphy_timing {
 216         u8 t_lpx;
 217         u8 t_hs_prepare;
 218         u8 t_hs_zero;
 219         u8 t_hs_trail;
 220         u8 t_hs_exit;
 221         u8 t_clk_post;
 222         u8 t_wakup_h;
 223         u8 t_wakup_l;
 224         u8 t_clk_pre;
 225         u8 t_ta_go;
 226         u8 t_ta_sure;
 227         u8 t_ta_wait;
 228 };
 229
 230 struct dsi_panel {
 231         struct videomode vm;
 232         int bpp;
 233 };
 234
 235 struct inno_mipi_dphy {
 236         struct device *dev;
 237         void __iomem *regs;
 238         struct clk *ref_clk;
 239         struct clk *pclk;
 240         struct reset_control *rst;
 241
 242         struct dsi_panel *panel;
 243         u32 lanes;
 244         u32 lane_mbps;
 245 };
 246
 247 static inline void inno_write(struct inno_mipi_dphy *inno, u32 reg, u32 val)
 248 {
 249         writel_relaxed(val, inno->regs + reg);
 250 }
 251
 252 static inline u32 inno_read(struct inno_mipi_dphy *inno, u32 reg)
 253 {
 254         return readl_relaxed(inno->regs + reg);
 255 }
 256
 257 static inline void inno_update_bits(struct inno_mipi_dphy *inno, u32 reg,
 258                                     u32 mask, u32 val)
 259 {
 260         u32 tmp, orig;
 261
 262         orig = inno_read(inno, reg);
 263         tmp = orig & ~mask;
 264         tmp |= val & mask;
 265         inno_write(inno, reg, tmp);
 266 }
 267
 268 static void mipi_dphy_timing_get_default(struct mipi_dphy_timing *timing,
 269                                          unsigned long period)
 270 {
 271         /* Global Operation Timing Parameters */
 272         timing->clkmiss = 0;
 273         timing->clkpost = 70000 + 52 * period;
 274         timing->clkpre = 8000;
 275         timing->clkprepare = 65000;
 276         timing->clksettle = 95000;
 277         timing->clktermen = 0;
 278         timing->clktrail = 80000;
 279         timing->clkzero = 260000;
 280         timing->dtermen = 0;
 281         timing->eot = 0;
 282         timing->hsexit = 120000;
 283         timing->hsprepare = 65000 + 5 * period;
 284         timing->hszero = 145000 + 5 * period;
 285         timing->hssettle = 85000 + 6 * period;
 286         timing->hsskip = 40000;
 287         timing->hstrail = max(4 * 8 * period, 60000 + 4 * 4 * period);
 288         timing->init = 100000000;
 289         timing->lpx = 60000;
 290         timing->taget = 5 * timing->lpx;
 291         timing->tago = 4 * timing->lpx;
 292         timing->tasure = timing->lpx;
 293         timing->wakeup = 1000000000;
 294 }
 295
 296 static u32 fre_to_period(u32 fre)
 297 {
 298         u32 integer = 0;
 299         u32 decimals = 0;
 300
 301         integer = 1000000000UL / fre;
 302         decimals = 1000000000UL % fre;
 303         if (decimals <= 40000000)
 304                 decimals = (decimals * 100) / (fre / 10);
 305         else if (decimals <= 400000000)
 306                 decimals = (decimals * 10) / (fre / 100);
 307         else
 308                 decimals = decimals / (fre / 1000);
 309         integer = integer * 1000 + decimals;
 310
 311         return integer;
 312 }
 313
 314 static void inno_mipi_dphy_timing_update(struct inno_mipi_dphy *inno,
 315                                          enum lane_type lane_type,
 316                                          struct inno_mipi_dphy_timing *t)
 317 {
 318         u32 base = lane_reg_offset[lane_type];
 319         u32 val, mask;
 320
 321         mask = M_T_HS_PREPARE;
 322         val = V_T_HS_PREPARE(t->t_hs_prepare);
 323         inno_update_bits(inno, base + T_HS_PREPARE_OFFSET, mask, val);
 324
 325         mask = M_T_HS_ZERO;
 326         val = V_T_HS_ZERO(t->t_hs_zero);
 327         inno_update_bits(inno, base + T_HS_ZERO_OFFSET, mask, val);
 328
 329         mask = M_T_HS_TRAIL;
 330         val = V_T_HS_TRAIL(t->t_hs_trail);
 331         inno_update_bits(inno, base + T_HS_TRAIL_OFFSET, mask, val);
 332
 333         mask = M_T_HS_EXIT;
 334         val = V_T_HS_EXIT(t->t_hs_exit);
 335         inno_update_bits(inno, base + T_HS_EXIT_OFFSET, mask, val);
 336
 337         if (lane_type == CLOCK_LANE) {
 338                 mask = M_T_CLK_POST;
 339                 val = V_T_CLK_POST(t->t_clk_post);
 340                 inno_update_bits(inno, base + T_CLK_POST_OFFSET, mask, val);
 341
 342                 mask = M_T_CLK_PRE;
 343                 val = V_T_CLK_PRE(t->t_clk_pre);
 344                 inno_update_bits(inno, base + T_CLK_PRE_OFFSET, mask, val);
 345         }
 346
 347         mask = M_T_WAKUP_H;
 348         val = V_T_WAKUP_H(t->t_wakup_h);
 349         inno_update_bits(inno, base + T_WAKUP_H_OFFSET, mask, val);
 350
 351         mask = M_T_WAKUP_L;
 352         val = V_T_WAKUP_L(t->t_wakup_l);
 353         inno_update_bits(inno, base + T_WAKUP_L_OFFSET, mask, val);
 354
 355         mask = M_T_LPX;
 356         val = V_T_LPX(t->t_lpx);
 357         inno_update_bits(inno, base + T_LPX_OFFSET, mask, val);
 358
 359         mask = M_T_TA_GO;
 360         val = V_T_TA_GO(t->t_ta_go);
 361         inno_update_bits(inno, base + T_TA_GO_OFFSET, mask, val);
 362
 363         mask = M_T_TA_SURE;
 364         val = V_T_TA_SURE(t->t_ta_sure);
 365         inno_update_bits(inno, base + T_TA_SURE_OFFSET, mask, val);
 366
 367         mask = M_T_TA_WAIT;
 368         val = V_T_TA_WAIT(t->t_ta_wait);
 369         inno_update_bits(inno, base + T_TA_WAIT_OFFSET, mask, val);
 370 }
 371
 372 static enum hs_clk_range inno_mipi_dphy_get_hs_clk_range(u32 lane_rate)
 373 {
 374         u32 range = lane_rate / USEC_PER_SEC;
 375
 376         if (range < 110)
 377                 return HS_CLK_RANGE_80_110_MHZ;
 378         else if (range < 150)
 379                 return HS_CLK_RANGE_110_150_MHZ;
 380         else if (range < 200)
 381                 return HS_CLK_RANGE_150_200_MHZ;
 382         else if (range < 250)
 383                 return HS_CLK_RANGE_200_250_MHZ;
 384         else if (range < 300)
 385                 return HS_CLK_RANGE_250_300_MHZ;
 386         else if (range < 400)
 387                 return HS_CLK_RANGE_400_500_MHZ;
 388         else if (range < 500)
 389                 return HS_CLK_RANGE_400_500_MHZ;
 390         else if (range < 600)
 391                 return HS_CLK_RANGE_500_600_MHZ;
 392         else if (range < 700)
 393                 return HS_CLK_RANGE_600_700_MHZ;
 394         else if (range < 800)
 395                 return HS_CLK_RANGE_700_800_MHZ;
 396         else
 397                 return HS_CLK_RANGE_800_1000_MHZ;
 398 }
 399
 400 static void inno_mipi_dphy_lane_timing_init(struct inno_mipi_dphy *inno,
 401                                             enum lane_type lane_type)
 402 {
 403         struct mipi_dphy_timing timing;
 404         struct inno_mipi_dphy_timing data;
 405         u32 txbyteclkhs = inno->lane_mbps * USEC_PER_SEC / 8;
 406         u32 txclkesc = 20000000;
 407         u32 UI = fre_to_period(inno->lane_mbps * USEC_PER_SEC);
 408         u32 unit;
 409         enum hs_clk_range range;
 410
 411         memset(&timing, 0, sizeof(timing));
 412         memset(&data, 0, sizeof(data));
 413
 414         mipi_dphy_timing_get_default(&timing, UI);
 415
 416         range = inno_mipi_dphy_get_hs_clk_range(inno->lane_mbps * USEC_PER_SEC);
 417
 418         if (lane_type == CLOCK_LANE)
 419                 data.t_hs_zero = clock_lane_t_hs_zero_val[range];
 420         else
 421                 data.t_hs_zero = data_lane_t_hs_zero_val[range];
 422
 423         data.t_hs_prepare = t_hs_prepare_val[range];
 424         data.t_hs_trail = t_hs_trail_val[range];
 425
 426         /* txbyteclkhs domain */
 427         unit = fre_to_period(txbyteclkhs);
 428         data.t_hs_exit = DIV_ROUND_UP(timing.hsexit, unit);
 429         data.t_clk_post = DIV_ROUND_UP(timing.clkpost, unit);
 430         data.t_clk_pre = DIV_ROUND_UP(timing.clkpre, unit);
 431         data.t_wakup_h = 0x3;
 432         data.t_wakup_l = 0xff;
 433         data.t_lpx = DIV_ROUND_UP(timing.lpx, unit) - 2;
 434
 435         /* txclkesc domain */
 436         unit = fre_to_period(txclkesc);
 437         data.t_ta_go =  DIV_ROUND_UP(timing.tago, unit);
 438         data.t_ta_sure = DIV_ROUND_UP(timing.tasure, unit);
 439         data.t_ta_wait = DIV_ROUND_UP(timing.taget, unit);
 440
 441         inno_mipi_dphy_timing_update(inno, lane_type, &data);
 442 }
 443
 444 static void inno_mipi_dphy_pll_init(struct inno_mipi_dphy *inno)
 445 {
 446         struct dsi_panel *panel = inno->panel;
 447         unsigned int i, pre;
 448         unsigned long mpclk, pllref, tmp;
 449         unsigned int target_mbps = 1000;
 450         unsigned int max_mbps = 1000;
 451         u32 fbdiv = 1, prediv = 1;
 452         u32 val, mask;
 453
 454         mpclk = DIV_ROUND_UP(panel->vm.pixelclock, USEC_PER_SEC);
 455         if (mpclk) {
 456                 /* take 1 / 0.9, since mbps must big than bandwidth of RGB */
 457                 tmp = mpclk * (panel->bpp / inno->lanes) * 10 / 9;
 458                 if (tmp < max_mbps)
 459                         target_mbps = tmp;
 460                 else
 461                         dev_err(inno->dev, "DPHY clock frequency is out of range\n");
 462         }
 463
 464         pllref = DIV_ROUND_UP(clk_get_rate(inno->ref_clk) / 2, USEC_PER_SEC);
 465         tmp = pllref;
 466
 467         for (i = 1; i < 6; i++) {
 468                 pre = pllref / i;
 469                 if ((tmp > (target_mbps % pre)) && (target_mbps / pre < 512)) {
 470                         tmp = target_mbps % pre;
 471                         prediv = i;
 472                         fbdiv = target_mbps / pre;
 473                 }
 474                 if (tmp == 0)
 475                         break;
 476         }
 477
 478         inno->lane_mbps = pllref / prediv * fbdiv;
 479
 480         mask = M_FBDIV_8 | M_PREDIV;
 481         val = V_FBDIV_8(fbdiv >> 8) | V_PREDIV(prediv);
 482         inno_update_bits(inno, INNO_PHY_PLL_CTRL_0, mask, val);
 483
 484         mask = M_FBDIV_7_0;
 485         val = V_FBDIV_7_0(fbdiv);
 486         inno_update_bits(inno, INNO_PHY_PLL_CTRL_1, mask, val);
 487
 488         dev_info(inno->dev, "fin=%ld, fout=%d, prediv=%d, fbdiv=%d\n",
 489                  pllref, inno->lane_mbps, prediv, fbdiv);
 490 }
 491
 492 static void inno_mipi_dphy_reset(struct inno_mipi_dphy *inno)
 493 {
 494         /* Reset analog */
 495         inno_write(inno, INNO_PHY_POWER_CTRL, 0xe0);
 496         udelay(10);
 497         /* Reset digital */
 498         inno_write(inno, INNO_PHY_DIG_CTRL, 0x1e);
 499         udelay(10);
 500         inno_write(inno, INNO_PHY_DIG_CTRL, 0x1f);
 501         udelay(10);
 502 }
 503
 504 static void inno_mipi_dphy_timing_init(struct inno_mipi_dphy *inno)
 505 {
 506         switch (inno->lanes) {
 507         case 4:
 508                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_3);
 509                 /* Fall through */
 510         case 3:
 511                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_2);
 512                 /* Fall through */
 513         case 2:
 514                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_1);
 515                 /* Fall through */
 516         case 1:
 517         default:
 518                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_0);
 519                 inno_mipi_dphy_lane_timing_init(inno, CLOCK_LANE);
 520                 break;
 521         }
 522 }
 523
 524 static inline void inno_mipi_dphy_lane_enable(struct inno_mipi_dphy *inno)
 525 {
 526         u32 val = 0;
 527         u32 mask = 0;
 528
 529         switch (inno->lanes) {
 530         case 4:
 531                 mask |= M_DATA_LANE_3_EN;
 532                 val |= V_DATA_LANE_3_EN;
 533                 /* Fall through */
 534         case 3:
 535                 mask |= M_DATA_LANE_2_EN;
 536                 val |= V_DATA_LANE_2_EN;
 537                 /* Fall through */
 538         case 2:
 539                 mask |= M_DATA_LANE_1_EN;
 540                 val |= V_DATA_LANE_1_EN;
 541                 /* Fall through */
 542         default:
 543         case 1:
 544                 mask |= M_DATA_LANE_0_EN | M_CLK_LANE_EN;
 545                 val |= V_DATA_LANE_0_EN | V_CLK_LANE_EN;
 546                 break;
 547         }
 548
 549         inno_update_bits(inno, INNO_PHY_LANE_CTRL, mask, val);
 550 }
 551
 552 static inline void inno_mipi_dphy_pll_ldo_enable(struct inno_mipi_dphy *inno)
 553 {
 554         inno_write(inno, INNO_PHY_POWER_CTRL, 0xe4);
 555         udelay(10);
 556 }
 557
 558 static int inno_mipi_dphy_power_on(struct phy *phy)
 559 {
 560         struct inno_mipi_dphy *inno = phy_get_drvdata(phy);
 561
 562         clk_prepare_enable(inno->ref_clk);
 563         clk_prepare_enable(inno->pclk);
 564
 565         if (inno->rst) {
 566                 /* MIPI DSI PHY APB software reset request. */
 567                 reset_control_assert(inno->rst);
 568                 usleep_range(20, 40);
 569                 reset_control_deassert(inno->rst);
 570         }
 571
 572         inno_mipi_dphy_pll_init(inno);
 573         inno_mipi_dphy_pll_ldo_enable(inno);
 574         inno_mipi_dphy_lane_enable(inno);
 575         inno_mipi_dphy_reset(inno);
 576         inno_mipi_dphy_timing_init(inno);
 577
 578         dev_info(inno->dev, "Inno MIPI-DPHY Power-On\n");
 579
 580         return 0;
 581 }
 582
 583 static inline void inno_mipi_dphy_lane_disable(struct inno_mipi_dphy *inno)
 584 {
 585         inno_update_bits(inno, INNO_PHY_LANE_CTRL, 0x7c, 0x00);
 586 }
 587
 588 static inline void inno_mipi_dphy_pll_ldo_disable(struct inno_mipi_dphy *inno)
 589 {
 590         inno_write(inno, INNO_PHY_POWER_CTRL, 0xe3);
 591         udelay(10);
 592 }
 593
 594 static int inno_mipi_dphy_power_off(struct phy *phy)
 595 {
 596         struct inno_mipi_dphy *inno = phy_get_drvdata(phy);
 597
 598         inno_mipi_dphy_lane_disable(inno);
 599         inno_mipi_dphy_pll_ldo_disable(inno);
 600
 601         clk_disable_unprepare(inno->pclk);
 602         clk_disable_unprepare(inno->ref_clk);
 603
 604         dev_info(inno->dev, "Inno MIPI-DPHY Power-Off\n");
 605
 606         return 0;
 607 }
 608
 609 static const struct phy_ops inno_mipi_dphy_ops = {
 610         .power_on = inno_mipi_dphy_power_on,
 611         .power_off = inno_mipi_dphy_power_off,
 612         .owner = THIS_MODULE,
 613 };
 614
 615 static int get_bpp(struct device_node *np)
 616 {
 617         u32 format = 0;
 618
 619         if (of_property_read_u32(np, "dsi,format", &format))
 620                 return 24;
 621
 622         switch (format) {
 623         case MIPI_DSI_FMT_RGB666_PACKED:
 624                 return 18;
 625         case MIPI_DSI_FMT_RGB565:
 626                 return 16;
 627         case MIPI_DSI_FMT_RGB888:
 628         case MIPI_DSI_FMT_RGB666:
 629         default:
 630                 return 24;
 631         }
 632 }
 633
 634 static int inno_mipi_dphy_parse_dt(struct device_node *np,
 635                                    struct inno_mipi_dphy *inno)
 636 {
 637         struct device_node *panel_node;
 638         struct dsi_panel *panel;
 639         int ret;
 640
 641         panel_node = of_parse_phandle(np, "rockchip,dsi-panel", 0);
 642         if (!panel_node) {
 643                 dev_err(inno->dev, "Missing 'rockchip,dsi-panel' property");
 644                 return -ENODEV;
 645         }
 646
 647         panel = devm_kzalloc(inno->dev, sizeof(*panel), GFP_KERNEL);
 648         if (!panel) {
 649                 ret = -ENOMEM;
 650                 goto put_panel_node;
 651         }
 652
 653         ret = of_get_videomode(panel_node, &panel->vm, 0);
 654         if (ret < 0)
 655                 goto put_panel_node;
 656
 657         panel->bpp = get_bpp(panel_node);
 658
 659         if (of_property_read_u32(panel_node, "dsi,lanes", &inno->lanes))
 660                 inno->lanes = 4;
 661
 662         of_node_put(panel_node);
 663
 664         inno->panel = panel;
 665
 666         return 0;
 667
 668 put_panel_node:
 669         of_node_put(panel_node);
 670         return ret;
 671 }
 672
 673 static int inno_mipi_dphy_probe(struct platform_device *pdev)
 674 {
 675         struct device_node *np = pdev->dev.of_node;
 676         struct inno_mipi_dphy *inno;
 677         struct phy *phy;
 678         struct phy_provider *phy_provider;
 679         struct resource *res;
 680         int ret;
 681
 682         inno = devm_kzalloc(&pdev->dev, sizeof(*inno), GFP_KERNEL);
 683         if (!inno)
 684                 return -ENOMEM;
 685
 686         inno->dev = &pdev->dev;
 687
 688         ret = inno_mipi_dphy_parse_dt(np, inno);
 689         if (ret) {
 690                 dev_err(&pdev->dev, "failed to parse DT\n");
 691                 return ret;
 692         }
 693
 694         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 695         inno->regs = devm_ioremap_resource(&pdev->dev, res);
 696         if (IS_ERR(inno->regs))
 697                 return PTR_ERR(inno->regs);
 698
 699         inno->ref_clk = devm_clk_get(&pdev->dev, "ref");
 700         if (IS_ERR(inno->ref_clk)) {
 701                 dev_err(&pdev->dev, "failed to get mipi dphy ref clk\n");
 702                 return PTR_ERR(inno->ref_clk);
 703         }
 704
 705         clk_set_rate(inno->ref_clk, 24000000);
 706
 707         inno->pclk = devm_clk_get(&pdev->dev, "pclk");
 708         if (IS_ERR(inno->pclk)) {
 709                 dev_err(&pdev->dev, "failed to get mipi dphy pclk\n");
 710                 return PTR_ERR(inno->pclk);
 711         }
 712
 713         inno->rst = devm_reset_control_get_optional(&pdev->dev, "apb");
 714         if (IS_ERR(inno->rst)) {
 715                 dev_info(&pdev->dev, "No reset control specified\n");
 716                 inno->rst = NULL;
 717         }
 718
 719         phy = devm_phy_create(&pdev->dev, NULL, &inno_mipi_dphy_ops);
 720         if (IS_ERR(phy)) {
 721                 dev_err(&pdev->dev, "failed to create MIPI D-PHY\n");
 722                 return PTR_ERR(phy);
 723         }
 724
 725         phy_set_drvdata(phy, inno);
 726
 727         phy_provider = devm_of_phy_provider_register(&pdev->dev,
 728                                                      of_phy_simple_xlate);
 729         if (IS_ERR(phy_provider)) {
 730                 dev_err(&pdev->dev, "failed to register phy provider\n");
 731                 return PTR_ERR(phy_provider);
 732         }
 733
 734         dev_info(&pdev->dev, "Inno MIPI-DPHY Driver Probe\n");
 735
 736         return 0;
 737 }
 738
 739 static const struct of_device_id inno_mipi_dphy_of_match[] = {
 740         { .compatible = "rockchip,rk3368-mipi-dphy", },
 741         { /* Sentinel */ }
 742 };
 743 MODULE_DEVICE_TABLE(of, inno_mipi_dphy_of_match);
 744
 745 static struct platform_driver inno_mipi_dphy_driver = {
 746         .probe  = inno_mipi_dphy_probe,
 747         .driver = {
 748                 .name   = DRV_NAME,
 749                 .of_match_table = inno_mipi_dphy_of_match,
 750         }
 751 };
 752
 753 module_platform_driver(inno_mipi_dphy_driver);
 754
 755 MODULE_DESCRIPTION("Innosilicon MIPI D-PHY Driver");
 756 MODULE_LICENSE("GPL v2");