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         struct phy *phy;
 238         void __iomem *regs;
 239         struct clk *ref_clk;
 240         struct clk *pclk;
 241         struct reset_control *rst;
 242
 243         struct dsi_panel *panel;
 244         u32 lanes;
 245         u32 lane_mbps;
 246 };
 247
 248 static inline void inno_write(struct inno_mipi_dphy *inno, u32 reg, u32 val)
 249 {
 250         writel_relaxed(val, inno->regs + reg);
 251 }
 252
 253 static inline u32 inno_read(struct inno_mipi_dphy *inno, u32 reg)
 254 {
 255         return readl_relaxed(inno->regs + reg);
 256 }
 257
 258 static inline void inno_update_bits(struct inno_mipi_dphy *inno, u32 reg,
 259                                     u32 mask, u32 val)
 260 {
 261         u32 tmp, orig;
 262
 263         orig = inno_read(inno, reg);
 264         tmp = orig & ~mask;
 265         tmp |= val & mask;
 266         inno_write(inno, reg, tmp);
 267 }
 268
 269 static void mipi_dphy_timing_get_default(struct mipi_dphy_timing *timing,
 270                                          unsigned long period)
 271 {
 272         /* Global Operation Timing Parameters */
 273         timing->clkmiss = 0;
 274         timing->clkpost = 70000 + 52 * period;
 275         timing->clkpre = 8000;
 276         timing->clkprepare = 65000;
 277         timing->clksettle = 95000;
 278         timing->clktermen = 0;
 279         timing->clktrail = 80000;
 280         timing->clkzero = 260000;
 281         timing->dtermen = 0;
 282         timing->eot = 0;
 283         timing->hsexit = 120000;
 284         timing->hsprepare = 65000 + 5 * period;
 285         timing->hszero = 145000 + 5 * period;
 286         timing->hssettle = 85000 + 6 * period;
 287         timing->hsskip = 40000;
 288         timing->hstrail = max(4 * 8 * period, 60000 + 4 * 4 * period);
 289         timing->init = 100000000;
 290         timing->lpx = 60000;
 291         timing->taget = 5 * timing->lpx;
 292         timing->tago = 4 * timing->lpx;
 293         timing->tasure = timing->lpx;
 294         timing->wakeup = 1000000000;
 295 }
 296
 297 static u32 fre_to_period(u32 fre)
 298 {
 299         u32 integer = 0;
 300         u32 decimals = 0;
 301
 302         integer = 1000000000UL / fre;
 303         decimals = 1000000000UL % fre;
 304         if (decimals <= 40000000)
 305                 decimals = (decimals * 100) / (fre / 10);
 306         else if (decimals <= 400000000)
 307                 decimals = (decimals * 10) / (fre / 100);
 308         else
 309                 decimals = decimals / (fre / 1000);
 310         integer = integer * 1000 + decimals;
 311
 312         return integer;
 313 }
 314
 315 static void inno_mipi_dphy_timing_update(struct inno_mipi_dphy *inno,
 316                                          enum lane_type lane_type,
 317                                          struct inno_mipi_dphy_timing *t)
 318 {
 319         u32 base = lane_reg_offset[lane_type];
 320         u32 val, mask;
 321
 322         mask = M_T_HS_PREPARE;
 323         val = V_T_HS_PREPARE(t->t_hs_prepare);
 324         inno_update_bits(inno, base + T_HS_PREPARE_OFFSET, mask, val);
 325
 326         mask = M_T_HS_ZERO;
 327         val = V_T_HS_ZERO(t->t_hs_zero);
 328         inno_update_bits(inno, base + T_HS_ZERO_OFFSET, mask, val);
 329
 330         mask = M_T_HS_TRAIL;
 331         val = V_T_HS_TRAIL(t->t_hs_trail);
 332         inno_update_bits(inno, base + T_HS_TRAIL_OFFSET, mask, val);
 333
 334         mask = M_T_HS_EXIT;
 335         val = V_T_HS_EXIT(t->t_hs_exit);
 336         inno_update_bits(inno, base + T_HS_EXIT_OFFSET, mask, val);
 337
 338         if (lane_type == CLOCK_LANE) {
 339                 mask = M_T_CLK_POST;
 340                 val = V_T_CLK_POST(t->t_clk_post);
 341                 inno_update_bits(inno, base + T_CLK_POST_OFFSET, mask, val);
 342
 343                 mask = M_T_CLK_PRE;
 344                 val = V_T_CLK_PRE(t->t_clk_pre);
 345                 inno_update_bits(inno, base + T_CLK_PRE_OFFSET, mask, val);
 346         }
 347
 348         mask = M_T_WAKUP_H;
 349         val = V_T_WAKUP_H(t->t_wakup_h);
 350         inno_update_bits(inno, base + T_WAKUP_H_OFFSET, mask, val);
 351
 352         mask = M_T_WAKUP_L;
 353         val = V_T_WAKUP_L(t->t_wakup_l);
 354         inno_update_bits(inno, base + T_WAKUP_L_OFFSET, mask, val);
 355
 356         mask = M_T_LPX;
 357         val = V_T_LPX(t->t_lpx);
 358         inno_update_bits(inno, base + T_LPX_OFFSET, mask, val);
 359
 360         mask = M_T_TA_GO;
 361         val = V_T_TA_GO(t->t_ta_go);
 362         inno_update_bits(inno, base + T_TA_GO_OFFSET, mask, val);
 363
 364         mask = M_T_TA_SURE;
 365         val = V_T_TA_SURE(t->t_ta_sure);
 366         inno_update_bits(inno, base + T_TA_SURE_OFFSET, mask, val);
 367
 368         mask = M_T_TA_WAIT;
 369         val = V_T_TA_WAIT(t->t_ta_wait);
 370         inno_update_bits(inno, base + T_TA_WAIT_OFFSET, mask, val);
 371 }
 372
 373 static enum hs_clk_range inno_mipi_dphy_get_hs_clk_range(u32 lane_rate)
 374 {
 375         u32 range = lane_rate / USEC_PER_SEC;
 376
 377         if (range < 110)
 378                 return HS_CLK_RANGE_80_110_MHZ;
 379         else if (range < 150)
 380                 return HS_CLK_RANGE_110_150_MHZ;
 381         else if (range < 200)
 382                 return HS_CLK_RANGE_150_200_MHZ;
 383         else if (range < 250)
 384                 return HS_CLK_RANGE_200_250_MHZ;
 385         else if (range < 300)
 386                 return HS_CLK_RANGE_250_300_MHZ;
 387         else if (range < 400)
 388                 return HS_CLK_RANGE_400_500_MHZ;
 389         else if (range < 500)
 390                 return HS_CLK_RANGE_400_500_MHZ;
 391         else if (range < 600)
 392                 return HS_CLK_RANGE_500_600_MHZ;
 393         else if (range < 700)
 394                 return HS_CLK_RANGE_600_700_MHZ;
 395         else if (range < 800)
 396                 return HS_CLK_RANGE_700_800_MHZ;
 397         else
 398                 return HS_CLK_RANGE_800_1000_MHZ;
 399 }
 400
 401 static void inno_mipi_dphy_lane_timing_init(struct inno_mipi_dphy *inno,
 402                                             enum lane_type lane_type)
 403 {
 404         struct mipi_dphy_timing timing;
 405         struct inno_mipi_dphy_timing data;
 406         u32 txbyteclkhs = inno->lane_mbps * USEC_PER_SEC / 8;
 407         u32 txclkesc = 20000000;
 408         u32 UI = fre_to_period(inno->lane_mbps * USEC_PER_SEC);
 409         u32 unit;
 410         enum hs_clk_range range;
 411
 412         memset(&timing, 0, sizeof(timing));
 413         memset(&data, 0, sizeof(data));
 414
 415         mipi_dphy_timing_get_default(&timing, UI);
 416
 417         range = inno_mipi_dphy_get_hs_clk_range(inno->lane_mbps * USEC_PER_SEC);
 418
 419         if (lane_type == CLOCK_LANE)
 420                 data.t_hs_zero = clock_lane_t_hs_zero_val[range];
 421         else
 422                 data.t_hs_zero = data_lane_t_hs_zero_val[range];
 423
 424         data.t_hs_prepare = t_hs_prepare_val[range];
 425         data.t_hs_trail = t_hs_trail_val[range];
 426
 427         /* txbyteclkhs domain */
 428         unit = fre_to_period(txbyteclkhs);
 429         data.t_hs_exit = DIV_ROUND_UP(timing.hsexit, unit);
 430         data.t_clk_post = DIV_ROUND_UP(timing.clkpost, unit);
 431         data.t_clk_pre = DIV_ROUND_UP(timing.clkpre, unit);
 432         data.t_wakup_h = 0x3;
 433         data.t_wakup_l = 0xff;
 434         data.t_lpx = DIV_ROUND_UP(timing.lpx, unit) - 2;
 435
 436         /* txclkesc domain */
 437         unit = fre_to_period(txclkesc);
 438         data.t_ta_go =  DIV_ROUND_UP(timing.tago, unit);
 439         data.t_ta_sure = DIV_ROUND_UP(timing.tasure, unit);
 440         data.t_ta_wait = DIV_ROUND_UP(timing.taget, unit);
 441
 442         inno_mipi_dphy_timing_update(inno, lane_type, &data);
 443 }
 444
 445 static void inno_mipi_dphy_pll_init(struct inno_mipi_dphy *inno)
 446 {
 447         struct dsi_panel *panel = inno->panel;
 448         unsigned int i, pre;
 449         unsigned long mpclk, pllref, tmp;
 450         unsigned int target_mbps = 1000;
 451         unsigned int max_mbps = 1000;
 452         u32 fbdiv = 1, prediv = 1;
 453         u32 val, mask;
 454
 455         mpclk = DIV_ROUND_UP(panel->vm.pixelclock, USEC_PER_SEC);
 456         if (mpclk) {
 457                 /* take 1 / 0.9, since mbps must big than bandwidth of RGB */
 458                 tmp = mpclk * (panel->bpp / inno->lanes) * 10 / 9;
 459                 if (tmp < max_mbps)
 460                         target_mbps = tmp;
 461                 else
 462                         dev_err(inno->dev, "DPHY clock frequency is out of range\n");
 463         }
 464
 465         pllref = DIV_ROUND_UP(clk_get_rate(inno->ref_clk) / 2, USEC_PER_SEC);
 466         tmp = pllref;
 467
 468         for (i = 1; i < 6; i++) {
 469                 pre = pllref / i;
 470                 if ((tmp > (target_mbps % pre)) && (target_mbps / pre < 512)) {
 471                         tmp = target_mbps % pre;
 472                         prediv = i;
 473                         fbdiv = target_mbps / pre;
 474                 }
 475                 if (tmp == 0)
 476                         break;
 477         }
 478
 479         inno->lane_mbps = pllref * fbdiv / prediv;
 480         phy_set_bus_width(inno->phy, inno->lane_mbps);
 481
 482         mask = M_FBDIV_8 | M_PREDIV;
 483         val = V_FBDIV_8(fbdiv >> 8) | V_PREDIV(prediv);
 484         inno_update_bits(inno, INNO_PHY_PLL_CTRL_0, mask, val);
 485
 486         mask = M_FBDIV_7_0;
 487         val = V_FBDIV_7_0(fbdiv);
 488         inno_update_bits(inno, INNO_PHY_PLL_CTRL_1, mask, val);
 489
 490         dev_info(inno->dev, "fin=%ld, fout=%d, prediv=%d, fbdiv=%d\n",
 491                  pllref, inno->lane_mbps, prediv, fbdiv);
 492 }
 493
 494 static void inno_mipi_dphy_reset(struct inno_mipi_dphy *inno)
 495 {
 496         /* Reset analog */
 497         inno_write(inno, INNO_PHY_POWER_CTRL, 0xe0);
 498         udelay(10);
 499         /* Reset digital */
 500         inno_write(inno, INNO_PHY_DIG_CTRL, 0x1e);
 501         udelay(10);
 502         inno_write(inno, INNO_PHY_DIG_CTRL, 0x1f);
 503         udelay(10);
 504 }
 505
 506 static void inno_mipi_dphy_timing_init(struct inno_mipi_dphy *inno)
 507 {
 508         switch (inno->lanes) {
 509         case 4:
 510                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_3);
 511                 /* Fall through */
 512         case 3:
 513                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_2);
 514                 /* Fall through */
 515         case 2:
 516                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_1);
 517                 /* Fall through */
 518         case 1:
 519         default:
 520                 inno_mipi_dphy_lane_timing_init(inno, DATA_LANE_0);
 521                 inno_mipi_dphy_lane_timing_init(inno, CLOCK_LANE);
 522                 break;
 523         }
 524 }
 525
 526 static inline void inno_mipi_dphy_lane_enable(struct inno_mipi_dphy *inno)
 527 {
 528         u32 val = 0;
 529         u32 mask = 0;
 530
 531         switch (inno->lanes) {
 532         case 4:
 533                 mask |= M_DATA_LANE_3_EN;
 534                 val |= V_DATA_LANE_3_EN;
 535                 /* Fall through */
 536         case 3:
 537                 mask |= M_DATA_LANE_2_EN;
 538                 val |= V_DATA_LANE_2_EN;
 539                 /* Fall through */
 540         case 2:
 541                 mask |= M_DATA_LANE_1_EN;
 542                 val |= V_DATA_LANE_1_EN;
 543                 /* Fall through */
 544         default:
 545         case 1:
 546                 mask |= M_DATA_LANE_0_EN | M_CLK_LANE_EN;
 547                 val |= V_DATA_LANE_0_EN | V_CLK_LANE_EN;
 548                 break;
 549         }
 550
 551         inno_update_bits(inno, INNO_PHY_LANE_CTRL, mask, val);
 552 }
 553
 554 static inline void inno_mipi_dphy_pll_ldo_enable(struct inno_mipi_dphy *inno)
 555 {
 556         inno_write(inno, INNO_PHY_POWER_CTRL, 0xe4);
 557         udelay(10);
 558 }
 559
 560 static int inno_mipi_dphy_power_on(struct phy *phy)
 561 {
 562         struct inno_mipi_dphy *inno = phy_get_drvdata(phy);
 563
 564         clk_prepare_enable(inno->ref_clk);
 565         clk_prepare_enable(inno->pclk);
 566
 567         if (inno->rst) {
 568                 /* MIPI DSI PHY APB software reset request. */
 569                 reset_control_assert(inno->rst);
 570                 usleep_range(20, 40);
 571                 reset_control_deassert(inno->rst);
 572         }
 573
 574         inno_mipi_dphy_pll_init(inno);
 575         inno_mipi_dphy_pll_ldo_enable(inno);
 576         inno_mipi_dphy_lane_enable(inno);
 577         inno_mipi_dphy_reset(inno);
 578         inno_mipi_dphy_timing_init(inno);
 579
 580         dev_info(inno->dev, "Inno MIPI-DPHY Power-On\n");
 581
 582         return 0;
 583 }
 584
 585 static inline void inno_mipi_dphy_lane_disable(struct inno_mipi_dphy *inno)
 586 {
 587         inno_update_bits(inno, INNO_PHY_LANE_CTRL, 0x7c, 0x00);
 588 }
 589
 590 static inline void inno_mipi_dphy_pll_ldo_disable(struct inno_mipi_dphy *inno)
 591 {
 592         inno_write(inno, INNO_PHY_POWER_CTRL, 0xe3);
 593         udelay(10);
 594 }
 595
 596 static int inno_mipi_dphy_power_off(struct phy *phy)
 597 {
 598         struct inno_mipi_dphy *inno = phy_get_drvdata(phy);
 599
 600         inno_mipi_dphy_lane_disable(inno);
 601         inno_mipi_dphy_pll_ldo_disable(inno);
 602
 603         clk_disable_unprepare(inno->pclk);
 604         clk_disable_unprepare(inno->ref_clk);
 605
 606         dev_info(inno->dev, "Inno MIPI-DPHY Power-Off\n");
 607
 608         return 0;
 609 }
 610
 611 static const struct phy_ops inno_mipi_dphy_ops = {
 612         .power_on = inno_mipi_dphy_power_on,
 613         .power_off = inno_mipi_dphy_power_off,
 614         .owner = THIS_MODULE,
 615 };
 616
 617 static int get_bpp(struct device_node *np)
 618 {
 619         u32 format = 0;
 620
 621         if (of_property_read_u32(np, "dsi,format", &format))
 622                 return 24;
 623
 624         switch (format) {
 625         case MIPI_DSI_FMT_RGB666_PACKED:
 626                 return 18;
 627         case MIPI_DSI_FMT_RGB565:
 628                 return 16;
 629         case MIPI_DSI_FMT_RGB888:
 630         case MIPI_DSI_FMT_RGB666:
 631         default:
 632                 return 24;
 633         }
 634 }
 635
 636 static int inno_mipi_dphy_parse_dt(struct device_node *np,
 637                                    struct inno_mipi_dphy *inno)
 638 {
 639         struct device_node *panel_node;
 640         struct dsi_panel *panel;
 641         int ret;
 642
 643         panel_node = of_parse_phandle(np, "rockchip,dsi-panel", 0);
 644         if (!panel_node) {
 645                 dev_err(inno->dev, "Missing 'rockchip,dsi-panel' property");
 646                 return -ENODEV;
 647         }
 648
 649         panel = devm_kzalloc(inno->dev, sizeof(*panel), GFP_KERNEL);
 650         if (!panel) {
 651                 ret = -ENOMEM;
 652                 goto put_panel_node;
 653         }
 654
 655         ret = of_get_videomode(panel_node, &panel->vm, 0);
 656         if (ret < 0)
 657                 goto put_panel_node;
 658
 659         panel->bpp = get_bpp(panel_node);
 660
 661         if (of_property_read_u32(panel_node, "dsi,lanes", &inno->lanes))
 662                 inno->lanes = 4;
 663
 664         of_node_put(panel_node);
 665
 666         inno->panel = panel;
 667
 668         return 0;
 669
 670 put_panel_node:
 671         of_node_put(panel_node);
 672         return ret;
 673 }
 674
 675 static int inno_mipi_dphy_probe(struct platform_device *pdev)
 676 {
 677         struct device_node *np = pdev->dev.of_node;
 678         struct inno_mipi_dphy *inno;
 679         struct phy_provider *phy_provider;
 680         struct resource *res;
 681         int ret;
 682
 683         inno = devm_kzalloc(&pdev->dev, sizeof(*inno), GFP_KERNEL);
 684         if (!inno)
 685                 return -ENOMEM;
 686
 687         inno->dev = &pdev->dev;
 688
 689         ret = inno_mipi_dphy_parse_dt(np, inno);
 690         if (ret) {
 691                 dev_err(&pdev->dev, "failed to parse DT\n");
 692                 return ret;
 693         }
 694
 695         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 696         inno->regs = devm_ioremap_resource(&pdev->dev, res);
 697         if (IS_ERR(inno->regs))
 698                 return PTR_ERR(inno->regs);
 699
 700         inno->ref_clk = devm_clk_get(&pdev->dev, "ref");
 701         if (IS_ERR(inno->ref_clk)) {
 702                 dev_err(&pdev->dev, "failed to get mipi dphy ref clk\n");
 703                 return PTR_ERR(inno->ref_clk);
 704         }
 705
 706         clk_set_rate(inno->ref_clk, 24000000);
 707
 708         inno->pclk = devm_clk_get(&pdev->dev, "pclk");
 709         if (IS_ERR(inno->pclk)) {
 710                 dev_err(&pdev->dev, "failed to get mipi dphy pclk\n");
 711                 return PTR_ERR(inno->pclk);
 712         }
 713
 714         inno->rst = devm_reset_control_get_optional(&pdev->dev, "apb");
 715         if (IS_ERR(inno->rst)) {
 716                 dev_info(&pdev->dev, "No reset control specified\n");
 717                 inno->rst = NULL;
 718         }
 719
 720         inno->phy = devm_phy_create(&pdev->dev, NULL, &inno_mipi_dphy_ops);
 721         if (IS_ERR(inno->phy)) {
 722                 dev_err(&pdev->dev, "failed to create MIPI D-PHY\n");
 723                 return PTR_ERR(inno->phy);
 724         }
 725
 726         phy_set_drvdata(inno->phy, inno);
 727
 728         phy_provider = devm_of_phy_provider_register(&pdev->dev,
 729                                                      of_phy_simple_xlate);
 730         if (IS_ERR(phy_provider)) {
 731                 dev_err(&pdev->dev, "failed to register phy provider\n");
 732                 return PTR_ERR(phy_provider);
 733         }
 734
 735         dev_info(&pdev->dev, "Inno MIPI-DPHY Driver Probe\n");
 736
 737         return 0;
 738 }
 739
 740 static const struct of_device_id inno_mipi_dphy_of_match[] = {
 741         { .compatible = "rockchip,rk3368-mipi-dphy", },
 742         { /* Sentinel */ }
 743 };
 744 MODULE_DEVICE_TABLE(of, inno_mipi_dphy_of_match);
 745
 746 static struct platform_driver inno_mipi_dphy_driver = {
 747         .probe  = inno_mipi_dphy_probe,
 748         .driver = {
 749                 .name   = DRV_NAME,
 750                 .of_match_table = inno_mipi_dphy_of_match,
 751         }
 752 };
 753
 754 module_platform_driver(inno_mipi_dphy_driver);
 755
 756 MODULE_DESCRIPTION("Innosilicon MIPI D-PHY Driver");
 757 MODULE_LICENSE("GPL v2");