drivers/video/rockchip/transmitter/rk32_mipi_dsi.c

   1 /*
   2  * Copyright (C) 2014 ROCKCHIP, Inc.
   3  * drivers/video/display/transmitter/rk32_mipi_dsi.c
   4  * author: libing@rock-chips.com
   5  * create date: 2014-04-10
   6  * debug /sys/kernel/debug/mipidsi*
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 /* config */
  18 #ifndef CONFIG_RK32_MIPI_DSI
  19 #include <common.h>
  20 #endif
  21
  22 #ifdef CONFIG_RK32_MIPI_DSI
  23 #define MIPI_DSI_REGISTER_IO    0
  24 #define CONFIG_MIPI_DSI_LINUX   0
  25 #endif
  26 #define DWC_DSI_VERSION                 0x3133302A
  27 #define DWC_DSI_VERSION_RK312x          0x3132312A
  28 #define DWC_DSI_VERSION_ERR             -1
  29
  30 #include <linux/kernel.h>
  31 #include <linux/init.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/slab.h>
  34 #include <linux/rk_fb.h>
  35 #include <linux/rk_screen.h>
  36 #include <linux/delay.h>
  37 #include <linux/clk.h>
  38 #include <linux/interrupt.h>
  39 #include <asm/div64.h>
  40
  41 #include <linux/fs.h>
  42 #include <linux/debugfs.h>
  43 #include <linux/seq_file.h>
  44 #include <linux/regulator/machine.h>
  45
  46 #include <linux/dma-mapping.h>
  47 #include "mipi_dsi.h"
  48 #include "rk32_mipi_dsi.h"
  49 #include <linux/rockchip/iomap.h>
  50 #include <linux/rockchip/cpu.h>
  51
  52 #define MIPI_DBG(x...)  /* printk(KERN_INFO x) */
  53
  54 #ifdef CONFIG_MIPI_DSI_LINUX
  55 #define MIPI_TRACE(x...)        /* printk(KERN_INFO x) */
  56 #else
  57 #define MIPI_TRACE(...)    \
  58         do {\
  59                 printf(__VA_ARGS__);\
  60                 printf("\n");\
  61         } while (0);
  62
  63 #endif
  64
  65 /*
  66 *                        Driver Version Note
  67 *
  68 *v1.0 : this driver is rk32 mipi dsi driver of rockchip;
  69 *v1.1 : add test eye pattern;
  70 *
  71 */
  72
  73 #define RK_MIPI_DSI_VERSION_AND_TIME  "rockchip mipi_dsi v1.1 2014-06-17"
  74
  75 static struct dsi *dsi0;
  76 static struct dsi *dsi1;
  77
  78 static int rk32_mipi_dsi_is_active(void *arg);
  79 static int rk32_mipi_dsi_enable_hs_clk(void *arg, u32 enable);
  80 static int rk32_mipi_dsi_enable_video_mode(void *arg, u32 enable);
  81 static int rk32_mipi_dsi_enable_command_mode(void *arg, u32 enable);
  82 static int rk32_mipi_dsi_is_enable(void *arg, u32 enable);
  83 static int rk32_mipi_power_down_DDR(void);
  84 static int rk32_mipi_power_up_DDR(void);
  85 int rk_mipi_screen_standby(u8 enable);
  86
  87 static int rk32_dsi_read_reg(struct dsi *dsi, u16 reg, u32 *pval)
  88 {
  89         if (dsi->ops.id == DWC_DSI_VERSION)
  90                 *pval = __raw_readl(dsi->host.membase + (reg - MIPI_DSI_HOST_OFFSET));
  91         else if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
  92                 if (reg >= MIPI_DSI_HOST_OFFSET)
  93                         *pval = __raw_readl(dsi->host.membase + (reg - MIPI_DSI_HOST_OFFSET));
  94                 else if (reg >= MIPI_DSI_PHY_OFFSET)
  95                         *pval = __raw_readl(dsi->phy.membase + (reg - MIPI_DSI_PHY_OFFSET));
  96         }
  97         return 0;
  98 }
  99
 100 static int rk32_dsi_write_reg(struct dsi *dsi, u16 reg, u32 *pval)
 101 {
 102         if (dsi->ops.id == DWC_DSI_VERSION)
 103                 __raw_writel(*pval, dsi->host.membase + (reg - MIPI_DSI_HOST_OFFSET));
 104         else if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
 105                 if (reg >= MIPI_DSI_HOST_OFFSET)
 106                         __raw_writel(*pval, dsi->host.membase + (reg - MIPI_DSI_HOST_OFFSET));
 107                 else if (reg >= MIPI_DSI_PHY_OFFSET)
 108                         __raw_writel(*pval, dsi->phy.membase + (reg - MIPI_DSI_PHY_OFFSET));
 109         }
 110         return 0;
 111 }
 112
 113 static int rk32_dsi_get_bits(struct dsi *dsi, u32 reg)
 114 {
 115         u32 val = 0;
 116         u32 bits = (reg >> 8) & 0xff;
 117         u16 reg_addr = (reg >> 16) & 0xffff;
 118         u8 offset = reg & 0xff;
 119
 120         if (bits < 32)
 121                 bits = (1 << bits) - 1;
 122         else
 123                 bits = 0xffffffff;
 124
 125         rk32_dsi_read_reg(dsi, reg_addr, &val);
 126         val >>= offset;
 127         val &= bits;
 128         return val;
 129 }
 130
 131 static int rk32_dsi_set_bits(struct dsi *dsi, u32 data, u32 reg)
 132 {
 133         static u32 val;
 134         u32 bits = (reg >> 8) & 0xff;
 135         u16 reg_addr = (reg >> 16) & 0xffff;
 136         u8 offset = reg & 0xff;
 137
 138         if (bits < 32)
 139                 bits = (1 << bits) - 1;
 140         else
 141                 bits = 0xffffffff;
 142
 143         if (bits != 0xffffffff)
 144                 rk32_dsi_read_reg(dsi, reg_addr, &val);
 145
 146         val &= ~(bits << offset);
 147         val |= (data & bits) << offset;
 148         rk32_dsi_write_reg(dsi, reg_addr, &val);
 149
 150         if (data > bits) {
 151                 MIPI_TRACE("%s error reg_addr:0x%04x, offset:%d, bits:0x%04x, value:0x%04x\n",
 152                                 __func__, reg_addr, offset, bits, data);
 153         }
 154         return 0;
 155 }
 156 #if 0
 157 static int rk32_dwc_phy_test_rd(struct dsi *dsi, unsigned char test_code)
 158 {
 159         int val = 0;
 160         rk32_dsi_set_bits(dsi, 1, phy_testclk);
 161         rk32_dsi_set_bits(dsi, test_code, phy_testdin);
 162         rk32_dsi_set_bits(dsi, 1, phy_testen);
 163         rk32_dsi_set_bits(dsi, 0, phy_testclk);
 164         rk32_dsi_set_bits(dsi, 0, phy_testen);;
 165
 166         rk32_dsi_set_bits(dsi, 0, phy_testen);
 167         val = rk32_dsi_get_bits(dsi, phy_testdout);
 168         rk32_dsi_set_bits(dsi, 1, phy_testclk);
 169         rk32_dsi_set_bits(dsi, 0, phy_testclk);
 170
 171         return val;
 172 }
 173 #endif
 174 static int rk32_dwc_phy_test_wr(struct dsi *dsi, unsigned char test_code, unsigned char *test_data, unsigned char size)
 175 {
 176         int i = 0;
 177
 178         MIPI_DBG("test_code=0x%x,test_data=0x%x\n", test_code, test_data[0]);
 179         rk32_dsi_set_bits(dsi, 0x10000 | test_code, PHY_TEST_CTRL1);
 180         rk32_dsi_set_bits(dsi, 0x2, PHY_TEST_CTRL0);
 181         rk32_dsi_set_bits(dsi, 0x0, PHY_TEST_CTRL0);
 182
 183         for (i = 0; i < size; i++) {
 184                 rk32_dsi_set_bits(dsi, test_data[i], PHY_TEST_CTRL1);
 185                 rk32_dsi_set_bits(dsi, 0x2, PHY_TEST_CTRL0);
 186                 rk32_dsi_set_bits(dsi, 0x0, PHY_TEST_CTRL0);
 187                 MIPI_DBG("rk32_dwc_phy_test_wr:%08x\n", rk32_dsi_get_bits(dsi, PHY_TEST_CTRL1));
 188         }
 189         return 0;
 190 }
 191
 192 static int rk32_phy_power_up(struct dsi *dsi)
 193 {
 194         /* enable ref clock */
 195         clk_prepare_enable(dsi->phy.refclk);
 196         clk_prepare_enable(dsi->dsi_pclk);
 197         clk_prepare_enable(dsi->dsi_pd);
 198         udelay(10);
 199
 200         switch (dsi->host.lane) {
 201         case 4:
 202                 rk32_dsi_set_bits(dsi, 3, n_lanes);
 203                 break;
 204         case 3:
 205                 rk32_dsi_set_bits(dsi, 2, n_lanes);
 206                 break;
 207         case 2:
 208                 rk32_dsi_set_bits(dsi, 1, n_lanes);
 209                 break;
 210         case 1:
 211                 rk32_dsi_set_bits(dsi, 0, n_lanes);
 212                 break;
 213         default:
 214                 break;
 215         }
 216         rk32_dsi_set_bits(dsi, 1, phy_shutdownz);
 217         rk32_dsi_set_bits(dsi, 1, phy_rstz);
 218         rk32_dsi_set_bits(dsi, 1, phy_enableclk);
 219         rk32_dsi_set_bits(dsi, 1, phy_forcepll);
 220
 221         return 0;
 222 }
 223
 224 static int rk312x_mipi_dsi_phy_set_gotp(struct dsi *dsi, u32 offset, int n)
 225 {
 226         u32 val = 0, temp = 0, Tlpx = 0;
 227         u32 ddr_clk = dsi->phy.ddr_clk;
 228         u32 Ttxbyte_clk = dsi->phy.Ttxbyte_clk;
 229         u32 Tsys_clk = dsi->phy.Tsys_clk;
 230         u32 Ttxclkesc = dsi->phy.Ttxclkesc;
 231         printk("%s : ddr_clk %d\n", __func__, ddr_clk);
 232         switch (offset) {
 233         case DPHY_CLOCK_OFFSET:
 234                 MIPI_DBG("******set DPHY_CLOCK_OFFSET gotp******\n");
 235                 break;
 236         case DPHY_LANE0_OFFSET:
 237                 MIPI_DBG("******set DPHY_LANE0_OFFSET gotp******\n");
 238                 break;
 239         case DPHY_LANE1_OFFSET:
 240                 MIPI_DBG("******set DPHY_LANE1_OFFSET gotp******\n");
 241                 break;
 242         case DPHY_LANE2_OFFSET:
 243                 MIPI_DBG("******set DPHY_LANE2_OFFSET gotp******\n");
 244                 break;
 245         case DPHY_LANE3_OFFSET:
 246                 MIPI_DBG("******set DPHY_LANE3_OFFSET gotp******\n");
 247                 break;
 248         default:
 249                 break;
 250         }
 251
 252         if (ddr_clk < 110 * MHz)
 253                 val = 0;
 254         else if (ddr_clk < 150 * MHz)
 255                 val = 1;
 256         else if (ddr_clk < 200 * MHz)
 257                 val = 2;
 258         else if (ddr_clk < 250 * MHz)
 259                 val = 3;
 260         else if (ddr_clk < 300 * MHz)
 261                 val = 4;
 262         else if (ddr_clk < 400 * MHz)
 263                 val = 5;
 264         else if (ddr_clk < 500 * MHz)
 265                 val = 6;
 266         else if (ddr_clk < 600 * MHz)
 267                 val = 7;
 268         else if (ddr_clk < 700 * MHz)
 269                 val = 8;
 270         else if (ddr_clk < 800 * MHz)
 271                 val = 9;
 272         else if (ddr_clk <= 1000 * MHz)
 273                 val = 10;
 274         printk("%s reg_ths_settle = 0x%x\n", __func__, val);
 275         rk32_dsi_set_bits(dsi, val, reg_ths_settle + offset);
 276
 277         if (ddr_clk < 110 * MHz)
 278                 val = 0x20;
 279         else if (ddr_clk < 150 * MHz)
 280                 val = 0x06;
 281         else if (ddr_clk < 200 * MHz)
 282                 val = 0x18;
 283         else if (ddr_clk < 250 * MHz)
 284                 val = 0x05;
 285         else if (ddr_clk < 300 * MHz)
 286                 val = 0x51;
 287         else if (ddr_clk < 400 * MHz)
 288                 val = 0x64;
 289         else if (ddr_clk < 500 * MHz)
 290                 val = 0x59;
 291         else if (ddr_clk < 600 * MHz)
 292                 val = 0x6a;
 293         else if (ddr_clk < 700 * MHz)
 294                 val = 0x3e;
 295         else if (ddr_clk < 800 * MHz)
 296                 val = 0x21;
 297         else if (ddr_clk <= 1000 * MHz)
 298                 val = 0x09;
 299         printk("%s reg_hs_ths_prepare = 0x%x\n", __func__, val);
 300         rk32_dsi_set_bits(dsi, val, reg_hs_ths_prepare + offset);
 301
 302         if (offset != DPHY_CLOCK_OFFSET) {
 303                 if (ddr_clk < 110 * MHz)
 304                         val = 2;
 305                 else if (ddr_clk < 150 * MHz)
 306                         val = 3;
 307                 else if (ddr_clk < 200 * MHz)
 308                         val = 4;
 309                 else if (ddr_clk < 250 * MHz)
 310                         val = 5;
 311                 else if (ddr_clk < 300 * MHz)
 312                         val = 6;
 313                 else if (ddr_clk < 400 * MHz)
 314                         val = 7;
 315                 else if (ddr_clk < 500 * MHz)
 316                         val = 7;
 317                 else if (ddr_clk < 600 * MHz)
 318                         val = 8;
 319                 else if (ddr_clk < 700 * MHz)
 320                         val = 8;
 321                 else if (ddr_clk < 800 * MHz)
 322                         val = 9;
 323                 else if (ddr_clk <= 1000 * MHz)
 324                         val = 9;
 325         } else {
 326                 if (ddr_clk < 110 * MHz)
 327                         val = 0x16;
 328                 else if (ddr_clk < 150 * MHz)
 329                         val = 0x16;
 330                 else if (ddr_clk < 200 * MHz)
 331                         val = 0x17;
 332                 else if (ddr_clk < 250 * MHz)
 333                         val = 0x17;
 334                 else if (ddr_clk < 300 * MHz)
 335                         val = 0x18;
 336                 else if (ddr_clk < 400 * MHz)
 337                         val = 0x19;
 338                 else if (ddr_clk < 500 * MHz)
 339                         val = 0x1b;
 340                 else if (ddr_clk < 600 * MHz)
 341                         val = 0x1d;
 342                 else if (ddr_clk < 700 * MHz)
 343                         val = 0x1e;
 344                 else if (ddr_clk < 800 * MHz)
 345                         val = 0x1f;
 346                 else if (ddr_clk <= 1000 * MHz)
 347                         val = 0x20;
 348         }
 349         printk("%s reg_hs_the_zero = 0x%x\n", __func__, val);
 350         rk32_dsi_set_bits(dsi, val, reg_hs_the_zero + offset);
 351
 352         if (ddr_clk < 110 * MHz)
 353                 val = 0x22;
 354         else if (ddr_clk < 150 * MHz)
 355                 val = 0x45;
 356         else if (ddr_clk < 200 * MHz)
 357                 val = 0x0b;
 358         else if (ddr_clk < 250 * MHz)
 359                 val = 0x16;
 360         else if (ddr_clk < 300 * MHz)
 361                 val = 0x2c;
 362         else if (ddr_clk < 400 * MHz)
 363                 val = 0x33;
 364         else if (ddr_clk < 500 * MHz)
 365                 val = 0x4e;
 366         else if (ddr_clk < 600 * MHz)
 367                 val = 0x3a;
 368         else if (ddr_clk < 700 * MHz)
 369                 val = 0x6a;
 370         else if (ddr_clk < 800 * MHz)
 371                 val = 0x29;
 372         else if (ddr_clk <= 1000 * MHz)
 373                 val = 0x21;     /* 0x27 */
 374
 375         printk("%s reg_hs_ths_trail = 0x%x\n", __func__, val);
 376
 377         rk32_dsi_set_bits(dsi, val, reg_hs_ths_trail + offset);
 378         val = 120000 / Ttxbyte_clk + 1;
 379         MIPI_DBG("reg_hs_ths_exit: %d, %d\n", val, val*Ttxbyte_clk/1000);
 380         rk32_dsi_set_bits(dsi, val, reg_hs_ths_exit + offset);
 381
 382         if (offset == DPHY_CLOCK_OFFSET) {
 383                 val = (60000 + 52*dsi->phy.UI) / Ttxbyte_clk + 1;
 384                 MIPI_DBG("reg_hs_tclk_post: %d, %d\n", val, val*Ttxbyte_clk/1000);
 385                 rk32_dsi_set_bits(dsi, val, reg_hs_tclk_post + offset);
 386                 val = 10*dsi->phy.UI / Ttxbyte_clk + 1;
 387                 MIPI_DBG("reg_hs_tclk_pre: %d, %d\n", val, val*Ttxbyte_clk/1000);
 388                 rk32_dsi_set_bits(dsi, val, reg_hs_tclk_pre + offset);
 389         }
 390
 391         val = 1010000000 / Tsys_clk + 1;
 392         MIPI_DBG("reg_hs_twakup: %d, %d\n", val, val*Tsys_clk/1000);
 393         if (val > 0x3ff) {
 394                 val = 0x2ff;
 395                 MIPI_DBG("val is too large, 0x3ff is the largest\n");
 396         }
 397         temp = (val >> 8) & 0x03;
 398         val &= 0xff;
 399         rk32_dsi_set_bits(dsi, temp, reg_hs_twakup_h + offset);
 400         rk32_dsi_set_bits(dsi, val, reg_hs_twakup_l + offset);
 401
 402         if (Ttxclkesc > 50000) {
 403                 val = 2*Ttxclkesc;
 404                 MIPI_DBG("Ttxclkesc:%d\n", Ttxclkesc);
 405         }
 406         val = val / Ttxbyte_clk;
 407         Tlpx = val*Ttxbyte_clk;
 408         MIPI_DBG("reg_hs_tlpx: %d, %d\n", val, Tlpx);
 409         val -= 2;
 410         rk32_dsi_set_bits(dsi, val, reg_hs_tlpx + offset);
 411
 412         Tlpx = 2*Ttxclkesc;
 413         val = 4*Tlpx / Ttxclkesc;
 414         MIPI_DBG("reg_hs_tta_go: %d, %d\n", val, val*Ttxclkesc);
 415         rk32_dsi_set_bits(dsi, val, reg_hs_tta_go + offset);
 416         val = 3 * Tlpx / 2 / Ttxclkesc;
 417         MIPI_DBG("reg_hs_tta_sure: %d, %d\n", val, val*Ttxclkesc);
 418         rk32_dsi_set_bits(dsi, val, reg_hs_tta_sure + offset);
 419         val = 5 * Tlpx / Ttxclkesc;
 420         MIPI_DBG("reg_hs_tta_wait: %d, %d\n", val, val*Ttxclkesc);
 421         rk32_dsi_set_bits(dsi, val, reg_hs_tta_wait + offset);
 422         return 0;
 423 }
 424
 425 static void rk312x_mipi_dsi_set_hs_clk(struct dsi *dsi)
 426 {
 427         rk32_dsi_set_bits(dsi, dsi->phy.prediv, reg_prediv);
 428         rk32_dsi_set_bits(dsi, dsi->phy.fbdiv & 0xff, reg_fbdiv);
 429         rk32_dsi_set_bits(dsi, (dsi->phy.fbdiv >> 8) & 0x01, reg_fbdiv_8);
 430 }
 431
 432 static int rk312x_phy_power_up(struct dsi *dsi)
 433 {
 434         /* enable ref clock */
 435         rk312x_mipi_dsi_set_hs_clk(dsi);
 436         clk_prepare_enable(dsi->phy.refclk);
 437         clk_prepare_enable(dsi->dsi_pclk);
 438         clk_prepare_enable(dsi->dsi_host_pclk);
 439         clk_prepare_enable(dsi->h2p_hclk);
 440         clk_prepare_enable(dsi->dsi_pd);
 441         udelay(10);
 442
 443         rk32_dsi_set_bits(dsi, 0xe4, DPHY_REGISTER1);
 444         switch (dsi->host.lane) {
 445         case 4:
 446                 rk32_dsi_set_bits(dsi, 1, lane_en_3);
 447         case 3:
 448                 rk32_dsi_set_bits(dsi, 1, lane_en_2);
 449         case 2:
 450                 rk32_dsi_set_bits(dsi, 1, lane_en_1);
 451         case 1:
 452                 rk32_dsi_set_bits(dsi, 1, lane_en_0);
 453                 rk32_dsi_set_bits(dsi, 1, lane_en_ck);
 454                 break;
 455         default:
 456                 break;
 457         }
 458
 459         rk32_dsi_set_bits(dsi, 0xe0, DPHY_REGISTER1);
 460         udelay(10);
 461
 462         rk32_dsi_set_bits(dsi, 0x1e, DPHY_REGISTER20);
 463         rk32_dsi_set_bits(dsi, 0x1f, DPHY_REGISTER20);
 464
 465         rk32_dsi_set_bits(dsi, 1, phy_enableclk);
 466
 467         return 0;
 468 }
 469
 470 static int rk_phy_power_up(struct dsi *dsi)
 471 {
 472         if (dsi->ops.id == DWC_DSI_VERSION)
 473                 rk32_phy_power_up(dsi);
 474         else if (dsi->ops.id == DWC_DSI_VERSION_RK312x)
 475                 rk312x_phy_power_up(dsi);
 476         return 0;
 477 }
 478
 479 static int rk32_phy_power_down(struct dsi *dsi)
 480 {
 481         rk32_dsi_set_bits(dsi, 0, phy_shutdownz);
 482         clk_disable_unprepare(dsi->phy.refclk);
 483         clk_disable_unprepare(dsi->dsi_pclk);
 484         clk_disable_unprepare(dsi->dsi_pd);
 485         return 0;
 486 }
 487
 488 static int rk312x_phy_power_down(struct dsi *dsi)
 489 {
 490         rk32_dsi_set_bits(dsi, 0x01, DPHY_REGISTER0);
 491         rk32_dsi_set_bits(dsi, 0xe3, DPHY_REGISTER1);
 492
 493         clk_disable_unprepare(dsi->phy.refclk);
 494         clk_disable_unprepare(dsi->dsi_pclk);
 495         clk_disable_unprepare(dsi->dsi_host_pclk);
 496         clk_disable_unprepare(dsi->h2p_hclk);
 497         clk_disable_unprepare(dsi->dsi_pd);
 498         return 0;
 499 }
 500
 501 static int rk_phy_power_down(struct dsi *dsi)
 502 {
 503         if (dsi->ops.id == DWC_DSI_VERSION)
 504                 rk32_phy_power_down(dsi);
 505         else if (dsi->ops.id == DWC_DSI_VERSION_RK312x)
 506                 rk312x_phy_power_down(dsi);
 507         return 0;
 508 }
 509
 510 static int rk32_phy_init(struct dsi *dsi)
 511 {
 512         u32 val = 0 , ddr_clk = 0, fbdiv = 0, prediv = 0;
 513         unsigned char test_data[2] = {0};
 514
 515         ddr_clk = dsi->phy.ddr_clk;
 516         prediv  = dsi->phy.prediv;
 517         fbdiv   = dsi->phy.fbdiv;
 518
 519         if (ddr_clk < 200 * MHz)
 520                 val = 0x0;
 521         else if (ddr_clk < 300 * MHz)
 522                 val = 0x1;
 523         else if (ddr_clk < 500 * MHz)
 524                 val = 0x2;
 525         else if (ddr_clk < 700 * MHz)
 526                 val = 0x3;
 527         else if (ddr_clk < 900 * MHz)
 528                 val = 0x4;
 529         else if (ddr_clk < 1100 * MHz)
 530                 val = 0x5;
 531         else if (ddr_clk < 1300 * MHz)
 532                 val = 0x6;
 533         else if (ddr_clk <= 1500 * MHz)
 534                 val = 0x7;
 535
 536         test_data[0] = 0x80 | val << 3 | 0x3;
 537         rk32_dwc_phy_test_wr(dsi, 0x10, test_data, 1);
 538
 539         test_data[0] = 0x8;
 540         rk32_dwc_phy_test_wr(dsi, 0x11, test_data, 1);
 541
 542         test_data[0] = 0x80 | 0x40;
 543         rk32_dwc_phy_test_wr(dsi, 0x12, test_data, 1);
 544
 545         if (ddr_clk < 90 * MHz)
 546                 val = 0x01;
 547         else if (ddr_clk < 100 * MHz)
 548                 val = 0x10;
 549         else if (ddr_clk < 110 * MHz)
 550                 val = 0x20;
 551         else if (ddr_clk < 130 * MHz)
 552                 val = 0x01;
 553         else if (ddr_clk < 140 * MHz)
 554                 val = 0x11;
 555         else if (ddr_clk < 150 * MHz)
 556                 val = 0x21;
 557         else if (ddr_clk < 170 * MHz)
 558                 val = 0x02;
 559         else if (ddr_clk < 180 * MHz)
 560                 val = 0x12;
 561         else if (ddr_clk < 200 * MHz)
 562                 val = 0x22;
 563         else if (ddr_clk < 220 * MHz)
 564                 val = 0x03;
 565         else if (ddr_clk < 240 * MHz)
 566                 val = 0x13;
 567         else if (ddr_clk < 250 * MHz)
 568                 val = 0x23;
 569         else if (ddr_clk < 270 * MHz)
 570                 val = 0x04;
 571         else if (ddr_clk < 300 * MHz)
 572                 val = 0x14;
 573         else if (ddr_clk < 330 * MHz)
 574                 val = 0x05;
 575         else if (ddr_clk < 360 * MHz)
 576                 val = 0x15;
 577         else if (ddr_clk < 400 * MHz)
 578                 val = 0x25;
 579         else if (ddr_clk < 450 * MHz)
 580                 val = 0x06;
 581         else if (ddr_clk < 500 * MHz)
 582                 val = 0x16;
 583         else if (ddr_clk < 550 * MHz)
 584                 val = 0x07;
 585         else if (ddr_clk < 600 * MHz)
 586                 val = 0x17;
 587         else if (ddr_clk < 650 * MHz)
 588                 val = 0x08;
 589         else if (ddr_clk < 700 * MHz)
 590                 val = 0x18;
 591         else if (ddr_clk < 750 * MHz)
 592                 val = 0x09;
 593         else if (ddr_clk < 800 * MHz)
 594                 val = 0x19;
 595         else if (ddr_clk < 850 * MHz)
 596                 val = 0x29;
 597         else if (ddr_clk < 900 * MHz)
 598                 val = 0x39;
 599         else if (ddr_clk < 950 * MHz)
 600                 val = 0x0a;
 601         else if (ddr_clk < 1000 * MHz)
 602                 val = 0x1a;
 603         else if (ddr_clk < 1050 * MHz)
 604                 val = 0x2a;
 605         else if (ddr_clk < 1100 * MHz)
 606                 val = 0x3a;
 607         else if (ddr_clk < 1150 * MHz)
 608                 val = 0x0b;
 609         else if (ddr_clk < 1200 * MHz)
 610                 val = 0x1b;
 611         else if (ddr_clk < 1250 * MHz)
 612                 val = 0x2b;
 613         else if (ddr_clk < 1300 * MHz)
 614                 val = 0x3b;
 615         else if (ddr_clk < 1350 * MHz)
 616                 val = 0x0c;
 617         else if (ddr_clk < 1400 * MHz)
 618                 val = 0x1c;
 619         else if (ddr_clk < 1450 * MHz)
 620                 val = 0x2c;
 621         else if (ddr_clk <= 1500 * MHz)
 622                 val = 0x3c;
 623
 624         test_data[0] = val << 1;
 625         rk32_dwc_phy_test_wr(dsi, code_hs_rx_lane0, test_data, 1);
 626
 627         test_data[0] = prediv - 1;
 628         rk32_dwc_phy_test_wr(dsi, code_pll_input_div_rat, test_data, 1);
 629         mdelay(2);
 630         test_data[0] = (fbdiv - 1) & 0x1f;
 631         rk32_dwc_phy_test_wr(dsi, code_pll_loop_div_rat, test_data, 1);
 632         mdelay(2);
 633         test_data[0] = (fbdiv - 1) >> 5 | 0x80;
 634         rk32_dwc_phy_test_wr(dsi, code_pll_loop_div_rat, test_data, 1);
 635         mdelay(2);
 636         test_data[0] = 0x30;
 637         rk32_dwc_phy_test_wr(dsi, code_pll_input_loop_div_rat, test_data, 1);
 638         mdelay(2);
 639
 640         test_data[0] = 0x4d;
 641         rk32_dwc_phy_test_wr(dsi, 0x20, test_data, 1);
 642
 643         test_data[0] = 0x3d;
 644         rk32_dwc_phy_test_wr(dsi, 0x21, test_data, 1);
 645
 646         test_data[0] = 0xdf;
 647         rk32_dwc_phy_test_wr(dsi, 0x21, test_data, 1);
 648
 649         test_data[0] =  0x7;
 650         rk32_dwc_phy_test_wr(dsi, 0x22, test_data, 1);
 651
 652         test_data[0] = 0x80 | 0x7;
 653         rk32_dwc_phy_test_wr(dsi, 0x22, test_data, 1);
 654
 655         test_data[0] = 0x80 | 15;
 656         rk32_dwc_phy_test_wr(dsi, code_hstxdatalanerequsetstatetime, test_data, 1);
 657
 658         test_data[0] = 0x80 | 85;
 659         rk32_dwc_phy_test_wr(dsi, code_hstxdatalanepreparestatetime, test_data, 1);
 660
 661         test_data[0] = 0x40 | 10;
 662         rk32_dwc_phy_test_wr(dsi, code_hstxdatalanehszerostatetime, test_data, 1);
 663
 664         return 0;
 665 }
 666
 667 static int rk312x_phy_init(struct dsi *dsi, int n)
 668 {
 669         /* DPHY init */
 670         rk32_dsi_set_bits(dsi, 0x11, DSI_DPHY_BITS(0x06<<2, 32, 0));
 671         rk32_dsi_set_bits(dsi, 0x11, DSI_DPHY_BITS(0x07<<2, 32, 0));
 672         rk32_dsi_set_bits(dsi, 0xcc, DSI_DPHY_BITS(0x09<<2, 32, 0));
 673 #if 0
 674         dsi_set_bits(0x4e, DSI_DPHY_BITS(0x08<<2, 32, 0));
 675         dsi_set_bits(0x84, DSI_DPHY_BITS(0x0a<<2, 32, 0));
 676 #endif
 677
 678         /*reg1[4] 0: enable a function of "pll phase for serial data being captured
 679                                  inside analog part"
 680                   1: disable it
 681         we disable it here because reg5[6:4] is not compatible with the HS speed.
 682         */
 683
 684         if (dsi->phy.ddr_clk >= 800*MHz) {
 685                 rk32_dsi_set_bits(dsi, 0x30, DSI_DPHY_BITS(0x05<<2, 32, 0));
 686         } else {
 687                 rk32_dsi_set_bits(dsi, 1, reg_da_ppfc);
 688         }
 689
 690         switch  (dsi->host.lane) {
 691         case 4:
 692                 rk312x_mipi_dsi_phy_set_gotp(dsi, DPHY_LANE3_OFFSET, n);
 693         case 3:
 694                 rk312x_mipi_dsi_phy_set_gotp(dsi, DPHY_LANE2_OFFSET, n);
 695         case 2:
 696                 rk312x_mipi_dsi_phy_set_gotp(dsi, DPHY_LANE1_OFFSET, n);
 697         case 1:
 698                 rk312x_mipi_dsi_phy_set_gotp(dsi, DPHY_LANE0_OFFSET, n);
 699                 rk312x_mipi_dsi_phy_set_gotp(dsi, DPHY_CLOCK_OFFSET, n);
 700                 break;
 701         default:
 702                 break;
 703         }
 704 /*
 705         rk32_dsi_set_bits(dsi, 0x00e4, reg1_phy);
 706         rk32_dsi_set_bits(dsi, 0x007d, reg0_phy);
 707         udelay(1000);
 708         rk32_dsi_set_bits(dsi, 0x00e0, reg1_phy);
 709         rk32_dsi_set_bits(dsi, 0x001e, reg20_phy);
 710         udelay(1000);
 711         rk32_dsi_set_bits(dsi, 0x001f, reg20_phy);
 712
 713         rk32_dsi_set_bits(dsi, 0x0063, reg10_phy);
 714         */
 715
 716         rk32_dsi_set_bits(dsi, 0x06, reg5_phy);
 717         rk32_dsi_set_bits(dsi, 0x6, reg10_4_6_phy);
 718         rk32_dsi_set_bits(dsi, 0x9, regb_phy);
 719         return 0;
 720
 721 }
 722
 723 static int rk_phy_init(struct dsi *dsi)
 724 {
 725         if (dsi->ops.id == DWC_DSI_VERSION)
 726                 rk32_phy_init(dsi);
 727         else if (dsi->ops.id == DWC_DSI_VERSION_RK312x)
 728                 rk312x_phy_init(dsi, 4);
 729         return 0;
 730 }
 731
 732 static int rk32_mipi_dsi_host_power_up(struct dsi *dsi)
 733 {
 734         int ret = 0;
 735         u32 val;
 736
 737         /* disable all interrupt */
 738         rk32_dsi_set_bits(dsi, 0x1fffff, INT_MKS0);
 739         rk32_dsi_set_bits(dsi, 0x3ffff, INT_MKS1);
 740
 741         rk32_mipi_dsi_is_enable(dsi, 1);
 742
 743         val = 10;
 744         while (!rk32_dsi_get_bits(dsi, phylock) && val--) {
 745                 udelay(10);
 746         };
 747
 748         if (val == 0) {
 749                 ret = -1;
 750                 MIPI_TRACE("%s:phylock fail.\n", __func__);
 751         }
 752
 753         val = 10;
 754         while (!rk32_dsi_get_bits(dsi, phystopstateclklane) && val--) {
 755                 udelay(10);
 756         };
 757
 758         return ret;
 759 }
 760
 761 static int rk32_mipi_dsi_host_power_down(struct dsi *dsi)
 762 {
 763         rk32_mipi_dsi_enable_video_mode(dsi, 0);
 764         rk32_mipi_dsi_enable_hs_clk(dsi, 0);
 765         rk32_mipi_dsi_is_enable(dsi, 0);
 766         return 0;
 767 }
 768
 769 static int rk32_mipi_dsi_host_init(struct dsi *dsi)
 770 {
 771         u32 val = 0, bytes_px = 0;
 772         struct mipi_dsi_screen *screen = &dsi->screen;
 773         u32 decimals = dsi->phy.Ttxbyte_clk, temp = 0, i = 0;
 774         u32 m = 1, lane = dsi->host.lane, Tpclk = dsi->phy.Tpclk,
 775                         Ttxbyte_clk = dsi->phy.Ttxbyte_clk;
 776
 777         rk32_dsi_set_bits(dsi, dsi->host.lane - 1, n_lanes);
 778         rk32_dsi_set_bits(dsi, dsi->vid, dpi_vcid);
 779
 780         switch (screen->face) {
 781         case OUT_P888:
 782                 rk32_dsi_set_bits(dsi, 5, dpi_color_coding);
 783                 bytes_px = 3;
 784                 break;
 785         case OUT_D888_P666:
 786         case OUT_P666:
 787                 rk32_dsi_set_bits(dsi, 3, dpi_color_coding);
 788                 rk32_dsi_set_bits(dsi, 1, en18_loosely);
 789                 bytes_px = 3;
 790                 break;
 791         case OUT_P565:
 792                 rk32_dsi_set_bits(dsi, 0, dpi_color_coding);
 793                 bytes_px = 2;
 794         default:
 795                 break;
 796         }
 797         if (dsi->ops.id == DWC_DSI_VERSION) {
 798                 rk32_dsi_set_bits(dsi, 1, hsync_active_low);
 799                 rk32_dsi_set_bits(dsi, 1, vsync_active_low);
 800
 801                 rk32_dsi_set_bits(dsi, 0, dataen_active_low);
 802                 rk32_dsi_set_bits(dsi, 0, colorm_active_low);
 803                 rk32_dsi_set_bits(dsi, 0, shutd_active_low);
 804         } else if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
 805                 rk32_dsi_set_bits(dsi, !screen->pin_hsync, hsync_active_low);
 806                 rk32_dsi_set_bits(dsi, !screen->pin_vsync, vsync_active_low);
 807
 808                 rk32_dsi_set_bits(dsi, screen->pin_den, dataen_active_low);
 809                 rk32_dsi_set_bits(dsi, 1, colorm_active_low);
 810                 rk32_dsi_set_bits(dsi, 1, shutd_active_low);
 811         }
 812
 813         rk32_dsi_set_bits(dsi, dsi->host.video_mode, vid_mode_type); /* burst mode */
 814
 815         switch (dsi->host.video_mode) {
 816         case VM_BM:
 817                 if (screen->type == SCREEN_DUAL_MIPI)
 818                         rk32_dsi_set_bits(dsi, screen->x_res / 2 + 4, vid_pkt_size);
 819                 else
 820                         rk32_dsi_set_bits(dsi, screen->x_res, vid_pkt_size);
 821                 break;
 822         case VM_NBMWSE:
 823         case VM_NBMWSP:
 824                 for (i = 8; i < 32; i++) {
 825                         temp = i * lane * Tpclk % Ttxbyte_clk;
 826                         if (decimals > temp) {
 827                                 decimals = temp;
 828                                 m = i;
 829                         }
 830                         if (decimals == 0)
 831                                 break;
 832                 }
 833
 834                 rk32_dsi_set_bits(dsi, screen->x_res / m + 1, num_chunks);
 835                 rk32_dsi_set_bits(dsi, m, vid_pkt_size);
 836                 temp = m * lane * Tpclk / Ttxbyte_clk - m * bytes_px;
 837                 MIPI_DBG("%s:%d, %d\n", __func__, m, temp);
 838
 839                 if (temp >= 12)
 840                         rk32_dsi_set_bits(dsi, temp - 12, null_pkt_size);
 841                 break;
 842         default:
 843                 break;
 844         }
 845
 846         /* rk32_dsi_set_bits(dsi, 0, CMD_MODE_CFG << 16); */
 847         if (screen->type == SCREEN_MIPI) {
 848                 rk32_dsi_set_bits(dsi, dsi->phy.Tpclk * (screen->x_res + screen->left_margin +
 849                                         screen->hsync_len + screen->right_margin) \
 850                                                 / dsi->phy.Ttxbyte_clk, vid_hline_time);
 851         } else {
 852                 rk32_dsi_set_bits(dsi, dsi->phy.Tpclk * (screen->x_res + 8 + screen->left_margin +
 853                                         screen->hsync_len + screen->right_margin) \
 854                                                 / dsi->phy.Ttxbyte_clk, vid_hline_time);
 855         }
 856         MIPI_DBG("dsi->phy.Tpclk = %d\n", dsi->phy.Tpclk);
 857         MIPI_DBG("screen->left_margin = %d\n", screen->left_margin);
 858         MIPI_DBG("dsi->phy.Ttxbyte_clk = %d\n", dsi->phy.Ttxbyte_clk);
 859         MIPI_DBG("screen->hsync_len = %d\n", screen->hsync_len);
 860         rk32_dsi_set_bits(dsi, dsi->phy.Tpclk * (screen->left_margin) / dsi->phy.Ttxbyte_clk,
 861                                         vid_hbp_time);
 862         rk32_dsi_set_bits(dsi, dsi->phy.Tpclk * (screen->hsync_len) / dsi->phy.Ttxbyte_clk,
 863                                         vid_hsa_time);
 864
 865         rk32_dsi_set_bits(dsi, screen->y_res , vid_active_lines);
 866         rk32_dsi_set_bits(dsi, screen->lower_margin, vid_vfp_lines);
 867         rk32_dsi_set_bits(dsi, screen->upper_margin, vid_vbp_lines);
 868         rk32_dsi_set_bits(dsi, screen->vsync_len, vid_vsa_lines);
 869
 870         dsi->phy.txclkesc = 20 * MHz;
 871         val = dsi->phy.txbyte_clk / dsi->phy.txclkesc + 1;
 872         dsi->phy.txclkesc = dsi->phy.txbyte_clk / val;
 873         rk32_dsi_set_bits(dsi, val, TX_ESC_CLK_DIVISION);
 874
 875         rk32_dsi_set_bits(dsi, 10, TO_CLK_DIVISION);
 876         rk32_dsi_set_bits(dsi, 1000, hstx_to_cnt); /* no sure */
 877         rk32_dsi_set_bits(dsi, 1000, lprx_to_cnt);
 878         rk32_dsi_set_bits(dsi, 100, phy_stop_wait_time);
 879
 880         /*
 881         rk32_dsi_set_bits(dsi, 0, outvact_lpcmd_time);
 882         rk32_dsi_set_bits(dsi, 0, invact_lpcmd_time);
 883         */
 884         rk32_dsi_set_bits(dsi, 20, phy_hs2lp_time);
 885         rk32_dsi_set_bits(dsi, 16, phy_lp2hs_time);
 886         /*
 887         rk32_dsi_set_bits(dsi, 87, phy_hs2lp_time_clk_lane);
 888         rk32_dsi_set_bits(dsi, 25, phy_hs2hs_time_clk_lane);
 889         */
 890         rk32_dsi_set_bits(dsi, 10000, max_rd_time);
 891
 892         rk32_dsi_set_bits(dsi, 1, lp_hfp_en);
 893         /* rk32_dsi_set_bits(dsi, 1, lp_hbp_en); */
 894         rk32_dsi_set_bits(dsi, 1, lp_vact_en);
 895         rk32_dsi_set_bits(dsi, 1, lp_vfp_en);
 896         rk32_dsi_set_bits(dsi, 1, lp_vbp_en);
 897         rk32_dsi_set_bits(dsi, 1, lp_vsa_en);
 898
 899         /* rk32_dsi_set_bits(dsi, 1, frame_bta_ack_en); */
 900         rk32_dsi_set_bits(dsi, 1, phy_enableclk);
 901         rk32_dsi_set_bits(dsi, 0, phy_tx_triggers);
 902         /*
 903         rk32_dsi_set_bits(dsi, 1, phy_txexitulpslan);
 904         rk32_dsi_set_bits(dsi, 1, phy_txexitulpsclk);
 905         */
 906         return 0;
 907 }
 908
 909 /*
 910  *      mipi protocol layer definition
 911  */
 912 static int rk_mipi_dsi_init(void *arg, u32 n)
 913 {
 914         u32 decimals = 1000, i = 0, pre = 0;
 915         struct dsi *dsi = arg;
 916         struct mipi_dsi_screen *screen = &dsi->screen;
 917
 918         if (!screen)
 919                 return -1;
 920
 921         if ((screen->type != SCREEN_MIPI) && (screen->type != SCREEN_DUAL_MIPI)) {
 922                 MIPI_TRACE("only mipi dsi lcd is supported!\n");
 923                 return -1;
 924         }
 925
 926         if (((screen->type == SCREEN_DUAL_MIPI) && (rk_mipi_get_dsi_num() == 1)) || ((screen->type == SCREEN_MIPI) && (rk_mipi_get_dsi_num() == 2))) {
 927                 MIPI_TRACE("dsi number and mipi type not match!\n");
 928                 return -1;
 929         }
 930
 931         dsi->phy.Tpclk = rk_fb_get_prmry_screen_pixclock();
 932
 933         if (dsi->phy.refclk)
 934                 dsi->phy.ref_clk = clk_get_rate(dsi->phy.refclk) ;
 935         if (dsi->ops.id == DWC_DSI_VERSION_RK312x)
 936                 dsi->phy.ref_clk = dsi->phy.ref_clk / 2; /* 1/2 of input refclk */
 937
 938         dsi->phy.sys_clk = dsi->phy.ref_clk;
 939
 940         printk("dsi->phy.sys_clk =%d\n", dsi->phy.sys_clk);
 941         if (dsi->ops.id == DWC_DSI_VERSION) {
 942                 if ((screen->hs_tx_clk <= 90 * MHz) || (screen->hs_tx_clk >= 1500 * MHz))
 943                         dsi->phy.ddr_clk = 1500 * MHz; /* default is 1.5HGz */
 944                 else
 945                         dsi->phy.ddr_clk = screen->hs_tx_clk;
 946         } else if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
 947                 if ((screen->hs_tx_clk <= 80 * MHz) || (screen->hs_tx_clk >= 1000 * MHz))
 948                         dsi->phy.ddr_clk = 1000 * MHz; /* default is 1GHz */
 949                 else
 950                         dsi->phy.ddr_clk = screen->hs_tx_clk;
 951         }
 952
 953         if (n != 0)
 954                 dsi->phy.ddr_clk = n;
 955
 956         decimals = dsi->phy.ref_clk;
 957         for (i = 1; i < 6; i++) {
 958                 pre = dsi->phy.ref_clk / i;
 959                 if ((decimals > (dsi->phy.ddr_clk % pre)) && (dsi->phy.ddr_clk / pre < 512)) {
 960                         decimals = dsi->phy.ddr_clk % pre;
 961                         dsi->phy.prediv = i;
 962                         dsi->phy.fbdiv = dsi->phy.ddr_clk / pre;
 963                 }
 964                 if (decimals == 0)
 965                         break;
 966         }
 967
 968         MIPI_DBG("prediv:%d, fbdiv:%d,dsi->phy.ddr_clk:%d\n", dsi->phy.prediv, dsi->phy.fbdiv, dsi->phy.ref_clk / dsi->phy.prediv * dsi->phy.fbdiv);
 969
 970         dsi->phy.ddr_clk = dsi->phy.ref_clk / dsi->phy.prediv * dsi->phy.fbdiv;
 971
 972         MIPI_DBG("dsi->phy.ddr_clk =%d\n", dsi->phy.ddr_clk);
 973         dsi->phy.txbyte_clk = dsi->phy.ddr_clk / 8;
 974
 975         dsi->phy.txclkesc = 20 * MHz; /* < 20MHz */
 976         dsi->phy.txclkesc = dsi->phy.txbyte_clk / (dsi->phy.txbyte_clk / dsi->phy.txclkesc + 1);
 977
 978         dsi->phy.pclk = div_u64(1000000000000llu, dsi->phy.Tpclk);
 979         dsi->phy.Ttxclkesc = div_u64(1000000000000llu, dsi->phy.txclkesc);
 980         dsi->phy.Tsys_clk = div_u64(1000000000000llu, dsi->phy.sys_clk);
 981         dsi->phy.Tddr_clk = div_u64(1000000000000llu, dsi->phy.ddr_clk);
 982         dsi->phy.Ttxbyte_clk = div_u64(1000000000000llu, dsi->phy.txbyte_clk);
 983
 984         dsi->phy.UI = dsi->phy.Tddr_clk;
 985         dsi->vid = 0;
 986
 987         if (screen->dsi_lane > 0 && screen->dsi_lane <= 4)
 988                 dsi->host.lane = screen->dsi_lane;
 989         else
 990                 dsi->host.lane = 4;
 991
 992         dsi->host.video_mode = VM_BM;
 993
 994         MIPI_DBG("UI:%d\n", dsi->phy.UI);
 995         MIPI_DBG("ref_clk:%d\n", dsi->phy.ref_clk);
 996         MIPI_DBG("pclk:%d, Tpclk:%d\n", dsi->phy.pclk, dsi->phy.Tpclk);
 997         MIPI_DBG("sys_clk:%d, Tsys_clk:%d\n", dsi->phy.sys_clk, dsi->phy.Tsys_clk);
 998         MIPI_DBG("ddr_clk:%d, Tddr_clk:%d\n", dsi->phy.ddr_clk, dsi->phy.Tddr_clk);
 999         MIPI_DBG("txbyte_clk:%d, Ttxbyte_clk:%d\n", dsi->phy.txbyte_clk,
1000                                 dsi->phy.Ttxbyte_clk);
1001         MIPI_DBG("txclkesc:%d, Ttxclkesc:%d\n", dsi->phy.txclkesc, dsi->phy.Ttxclkesc);
1002
1003         mdelay(10);
1004         rk_phy_power_up(dsi);
1005         rk32_mipi_dsi_host_power_up(dsi);
1006         rk_phy_init(dsi);
1007         rk32_mipi_dsi_host_init(dsi);
1008
1009         return 0;
1010 }
1011
1012 static int rk32_mipi_dsi_is_enable(void *arg, u32 enable)
1013 {
1014         struct dsi *dsi = arg;
1015
1016         rk32_dsi_set_bits(dsi, enable, shutdownz);
1017         return 0;
1018 }
1019
1020 static int rk32_mipi_dsi_enable_video_mode(void *arg, u32 enable)
1021 {
1022         struct dsi *dsi = arg;
1023
1024         rk32_dsi_set_bits(dsi, !enable, cmd_video_mode);
1025         return 0;
1026 }
1027
1028 static int rk32_mipi_dsi_enable_command_mode(void *arg, u32 enable)
1029 {
1030         struct dsi *dsi = arg;
1031
1032         rk32_dsi_set_bits(dsi, enable, cmd_video_mode);
1033         return 0;
1034 }
1035
1036 static int rk32_mipi_dsi_enable_hs_clk(void *arg, u32 enable)
1037 {
1038         struct dsi *dsi = arg;
1039
1040         rk32_dsi_set_bits(dsi, enable, phy_txrequestclkhs);
1041         return 0;
1042 }
1043
1044 static int rk32_mipi_dsi_is_active(void *arg)
1045 {
1046         struct dsi *dsi = arg;
1047
1048         return rk32_dsi_get_bits(dsi, shutdownz);
1049 }
1050
1051 static int rk32_mipi_dsi_send_packet(void *arg, unsigned char cmds[], u32 length)
1052 {
1053         struct dsi *dsi = arg;
1054         unsigned char *regs;
1055         u32 type, liTmp = 0, i = 0, j = 0, data = 0;
1056
1057         if (rk32_dsi_get_bits(dsi, gen_cmd_full) == 1) {
1058                 MIPI_TRACE("gen_cmd_full\n");
1059                 return -1;
1060         }
1061         regs = kmalloc(0x400, GFP_KERNEL);
1062         if (!regs) {
1063                 printk("request regs fail!\n");
1064                 return -ENOMEM;
1065         }
1066         memcpy(regs, cmds, length);
1067
1068         liTmp = length - 2;
1069         type = regs[1];
1070
1071         switch (type) {
1072         case DTYPE_DCS_SWRITE_0P:
1073                 rk32_dsi_set_bits(dsi, regs[0], dcs_sw_0p_tx);
1074                 data = regs[2] << 8 | type;
1075                 break;
1076         case DTYPE_DCS_SWRITE_1P:
1077                 rk32_dsi_set_bits(dsi, regs[0], dcs_sw_1p_tx);
1078                 data = regs[2] << 8 | type;
1079                 data |= regs[3] << 16;
1080                 break;
1081         case DTYPE_DCS_LWRITE:
1082                 rk32_dsi_set_bits(dsi, regs[0], dcs_lw_tx);
1083                 for (i = 0; i < liTmp; i++) {
1084                         regs[i] = regs[i+2];
1085                 }
1086                 for (i = 0; i < liTmp; i++) {
1087                         j = i % 4;
1088                         data |= regs[i] << (j * 8);
1089                         if (j == 3 || ((i + 1) == liTmp)) {
1090                                 if (rk32_dsi_get_bits(dsi, gen_pld_w_full) == 1) {
1091                                         MIPI_TRACE("gen_pld_w_full :%d\n", i);
1092                                         break;
1093                                 }
1094                                 rk32_dsi_set_bits(dsi, data, GEN_PLD_DATA);
1095                                 MIPI_DBG("write GEN_PLD_DATA:%d, %08x\n", i, data);
1096                                 data = 0;
1097                         }
1098                 }
1099                 data = type;
1100                 data |= (liTmp & 0xffff) << 8;
1101                 break;
1102         case DTYPE_GEN_LWRITE:
1103                 rk32_dsi_set_bits(dsi, regs[0], gen_lw_tx);
1104                 for (i = 0; i < liTmp; i++) {
1105                         regs[i] = regs[i+2];
1106                 }
1107                 for (i = 0; i < liTmp; i++) {
1108                         j = i % 4;
1109                         data |= regs[i] << (j * 8);
1110                         if (j == 3 || ((i + 1) == liTmp)) {
1111                                 if (rk32_dsi_get_bits(dsi, gen_pld_w_full) == 1) {
1112                                         MIPI_TRACE("gen_pld_w_full :%d\n", i);
1113                                         break;
1114                                 }
1115                                 rk32_dsi_set_bits(dsi, data, GEN_PLD_DATA);
1116                                 MIPI_DBG("write GEN_PLD_DATA:%d, %08x\n", i, data);
1117                                 data = 0;
1118                         }
1119                 }
1120                 data = (dsi->vid << 6) | type;
1121                 data |= (liTmp & 0xffff) << 8;
1122                 break;
1123         case DTYPE_GEN_SWRITE_2P:
1124                 rk32_dsi_set_bits(dsi, regs[0], gen_sw_2p_tx);
1125                 for (i = 0; i < liTmp; i++) {
1126                         regs[i] = regs[i+2];
1127                 }
1128                 for (i = 0; i < liTmp; i++) {
1129                         j = i % 4;
1130                         data |= regs[i] << (j * 8);
1131                         if (j == 3 || ((i + 1) == liTmp)) {
1132                                 if (rk32_dsi_get_bits(dsi, gen_pld_w_full) == 1) {
1133                                         MIPI_TRACE("gen_pld_w_full :%d\n", i);
1134                                         break;
1135                                 }
1136                                 rk32_dsi_set_bits(dsi, data, GEN_PLD_DATA);
1137                                 MIPI_DBG("write GEN_PLD_DATA:%d, %08x\n", i, data);
1138                                 data = 0;
1139                         }
1140                 }
1141                 data = type;
1142                 data |= (liTmp & 0xffff) << 8;
1143                 break;
1144         case DTYPE_GEN_SWRITE_1P:
1145                 rk32_dsi_set_bits(dsi, regs[0], gen_sw_1p_tx);
1146                 data = type;
1147                 data |= regs[2] << 8;
1148                 data |= regs[3] << 16;
1149                 break;
1150         case DTYPE_GEN_SWRITE_0P:
1151                 rk32_dsi_set_bits(dsi, regs[0], gen_sw_0p_tx);
1152                 data =  type;
1153                 data |= regs[2] << 8;
1154                 break;
1155         default:
1156                 printk("0x%x:this type not suppport!\n", type);
1157         }
1158
1159         MIPI_DBG("%d command sent in %s size:%d\n", __LINE__, regs[0] ? "LP mode" : "HS mode", liTmp);
1160
1161         MIPI_DBG("write GEN_HDR:%08x\n", data);
1162         rk32_dsi_set_bits(dsi, data, GEN_HDR);
1163
1164         i = 10;
1165         while (!rk32_dsi_get_bits(dsi, gen_cmd_empty) && i--) {
1166                 MIPI_DBG(".");
1167                 udelay(10);
1168         }
1169         udelay(10);
1170         kfree(regs);
1171         return 0;
1172 }
1173
1174 static int rk32_mipi_dsi_read_dcs_packet(void *arg, unsigned char *data1, u32 n)
1175 {
1176         struct dsi *dsi = arg;
1177         unsigned char regs[2];
1178         u32 data = 0;
1179         int type = 0x06;
1180         regs[0] = LPDT;
1181         regs[1] = 0x0a;
1182         n = n - 1;
1183
1184         rk32_dsi_set_bits(dsi, regs[0], dcs_sr_0p_tx);
1185         /*
1186         if(type == DTYPE_GEN_SWRITE_0P)
1187                 data = (dsi->vid << 6) | (n << 4) | type;
1188         else
1189                 data = (dsi->vid << 6) | ((n-1) << 4) | type;
1190         */
1191
1192         data |= regs[1] << 8 | type;
1193
1194         printk("write GEN_HDR:%08x\n", data);
1195
1196         rk32_dsi_set_bits(dsi, 0xFFFF, bta_to_cnt);
1197         rk32_dsi_set_bits(dsi, 1, bta_en);
1198         rk32_dsi_set_bits(dsi, data, GEN_HDR);
1199         udelay(20);
1200
1201         printk("rk32_mipi_dsi_read_dcs_packet==0x%x\n", rk32_dsi_get_bits(dsi, GEN_PLD_DATA));
1202         rk32_dsi_set_bits(dsi, 0, bta_en);
1203
1204         return 0;
1205 }
1206
1207 static int rk32_mipi_dsi_power_up(void *arg)
1208 {
1209         struct dsi *dsi = arg;
1210
1211         rk32_phy_power_up(dsi);
1212         rk32_mipi_dsi_host_power_up(dsi);
1213         return 0;
1214 }
1215
1216 static int rk32_mipi_dsi_power_down(void *arg)
1217 {
1218         struct dsi *dsi = arg;
1219         struct mipi_dsi_screen *screen = &dsi->screen;
1220
1221         if (!screen)
1222                 return -1;
1223
1224         rk32_mipi_dsi_host_power_down(dsi);
1225         rk_phy_power_down(dsi);
1226
1227         MIPI_TRACE("%s:%d\n", __func__, __LINE__);
1228         return 0;
1229 }
1230
1231 static int rk32_mipi_dsi_get_id(void *arg)
1232 {
1233         u32 id = 0;
1234         struct dsi *dsi = arg;
1235
1236         id = rk32_dsi_get_bits(dsi, VERSION);
1237         return id;
1238 }
1239
1240 /* the most top level of mipi dsi init */
1241 static int rk_mipi_dsi_probe(struct dsi *dsi)
1242 {
1243         int ret = 0;
1244
1245         register_dsi_ops(dsi->dsi_id, &dsi->ops);
1246         ret = dsi_probe_current_chip(dsi->dsi_id);
1247         if (ret) {
1248                 MIPI_TRACE("mipi dsi probe fail\n");
1249                 return -ENODEV;
1250         }
1251         return 0;
1252 }
1253
1254 #ifdef MIPI_DSI_REGISTER_IO
1255 #include <linux/proc_fs.h>
1256 #include <asm/uaccess.h>
1257 #include <linux/slab.h>
1258
1259 int reg_proc_write(struct file *file, const char __user *buff, size_t count, loff_t *offp)
1260 {
1261         int ret = -1, i = 0;
1262         u32 read_val = 0;
1263         char *buf = kmalloc(count, GFP_KERNEL);
1264         char *data = buf;
1265         char str[32];
1266         char command = 0;
1267         u64 regs_val = 0;
1268         memset(buf, 0, count);
1269         ret = copy_from_user((void *)buf, buff, count);
1270         data = strstr(data, "-");
1271         if (data == NULL)
1272                 goto reg_proc_write_exit;
1273         command = *(++data);
1274         switch (command) {
1275         case 'w':
1276                 while (1) {
1277                         data = strstr(data, "0x");
1278                         if (data == NULL)
1279                                 goto reg_proc_write_exit;
1280                         sscanf(data, "0x%llx", &regs_val);
1281                         if ((regs_val & 0xffff00000000ULL) == 0)
1282                                 goto reg_proc_write_exit;
1283                         read_val = regs_val & 0xffffffff;
1284                         printk("regs_val=0x%llx\n", regs_val);
1285                         rk32_dsi_write_reg(dsi0, regs_val >> 32, &read_val);
1286                         rk32_dsi_read_reg(dsi0, regs_val >> 32, &read_val);
1287                         regs_val &= 0xffffffff;
1288                         if (read_val != regs_val)
1289                                 MIPI_TRACE("%s fail:0x%08x\n", __func__, read_val);
1290                         data += 3;
1291                         msleep(1);
1292                 }
1293                 break;
1294         case 'r':
1295                 data = strstr(data, "0x");
1296                 if (data == NULL) {
1297                         goto reg_proc_write_exit;
1298                 }
1299                 sscanf(data, "0x%llx", &regs_val);
1300                 rk32_dsi_read_reg(dsi0, (u16)regs_val, &read_val);
1301                 MIPI_TRACE("*%04x : %08x\n", (u16)regs_val, read_val);
1302                 msleep(1);
1303                 break;
1304         case 's':
1305                 while (*(++data) == ' ')
1306                         ;
1307                 sscanf(data, "%d", &read_val);
1308                 if (read_val == 11)
1309                         read_val = 11289600;
1310                 else
1311                         read_val *= MHz;
1312                 break;
1313         case 'd':
1314         case 'g':
1315         case 'c':
1316                 while (*(++data) == ' ')
1317                         ;
1318                 i = 0;
1319                 MIPI_TRACE("****%d:%d\n", data-buf, count);
1320                 do {
1321                         if (i > 31) {
1322                                 MIPI_TRACE("payload entry is larger than 32\n");
1323                                 break;
1324                         }
1325                         sscanf(data, "%x,", (unsigned int *)(str + i)); /* -c 1,29,02,03,05,06,> pro */
1326                         data = strstr(data, ",");
1327                         if (data == NULL)
1328                                 break;
1329                         data++;
1330                         i++;
1331                 } while (1);
1332                 read_val = i;
1333                 i = 2;
1334                 while (i--) {
1335                         msleep(10);
1336                         if (command == 'd')
1337                                 rk32_mipi_dsi_send_packet(dsi0, str, read_val);
1338                         else
1339                                 rk32_mipi_dsi_send_packet(dsi0, str, read_val);
1340                 }
1341                 i = 1;
1342                 while (i--) {
1343                         msleep(1000);
1344                 }
1345                 break;
1346         default:
1347                 break;
1348         }
1349
1350 reg_proc_write_exit:
1351         kfree(buf);
1352         msleep(20);
1353         return count;
1354 }
1355
1356 int reg_proc_read(struct file *file, char __user *buff, size_t count,
1357                                         loff_t *offp)
1358 {
1359         int i = 0;
1360         u32 val = 0;
1361
1362         for (i = VERSION; i < (VERSION + (0xdc << 16)); i += 4<<16) {
1363                 val = rk32_dsi_get_bits(dsi0, i);
1364                 MIPI_TRACE("%04x: %08x\n", i>>16, val);
1365                 msleep(1);
1366         }
1367
1368         MIPI_TRACE("\n");
1369         return -1;
1370 }
1371
1372 int reg_proc_open(struct inode *inode, struct file *file)
1373 {
1374         return 0;
1375 }
1376
1377 int reg_proc_close(struct inode *inode, struct file *file)
1378 {
1379         return 0;
1380 }
1381
1382 struct file_operations reg_proc_fops = {
1383         .owner = THIS_MODULE,
1384         .open = reg_proc_open,
1385         .release = reg_proc_close,
1386         .write = reg_proc_write,
1387         .read = reg_proc_read,
1388 };
1389
1390 int reg_proc_write1(struct file *file, const char __user *buff, size_t count, loff_t *offp)
1391 {
1392         int ret = -1, i = 0;
1393         u32 read_val = 0;
1394         char *buf = kmalloc(count, GFP_KERNEL);
1395         char *data = buf;
1396         char str[32];
1397         char command = 0;
1398         u64 regs_val = 0;
1399         memset(buf, 0, count);
1400         ret = copy_from_user((void *)buf, buff, count);
1401
1402         data = strstr(data, "-");
1403         if (data == NULL)
1404                 goto reg_proc_write_exit;
1405         command = *(++data);
1406
1407         switch (command) {
1408         case 'w':
1409                 while (1) {
1410                         data = strstr(data, "0x");
1411                         if (data == NULL)
1412                                 goto reg_proc_write_exit;
1413                         sscanf(data, "0x%llx", &regs_val);
1414                         if ((regs_val & 0xffff00000000ULL) == 0)
1415                                 goto reg_proc_write_exit;
1416                         read_val = regs_val & 0xffffffff;
1417                         rk32_dsi_write_reg(dsi1, regs_val >> 32, &read_val);
1418                         rk32_dsi_read_reg(dsi1, regs_val >> 32, &read_val);
1419                         regs_val &= 0xffffffff;
1420                         if (read_val != regs_val)
1421                                 MIPI_TRACE("%s fail:0x%08x\n", __func__, read_val);
1422                         data += 3;
1423                         msleep(1);
1424                 }
1425                 break;
1426         case 'r':
1427                 data = strstr(data, "0x");
1428                 if (data == NULL)
1429                         goto reg_proc_write_exit;
1430                 sscanf(data, "0x%llx", &regs_val);
1431                 rk32_dsi_read_reg(dsi1, (u16)regs_val, &read_val);
1432                 MIPI_TRACE("*%04x : %08x\n", (u16)regs_val, read_val);
1433                 msleep(1);
1434                 break;
1435         case 's':
1436                 while (*(++data) == ' ')
1437                         ;
1438                 sscanf(data, "%d", &read_val);
1439                 if (read_val == 11)
1440                         read_val = 11289600;
1441                 else
1442                         read_val *= MHz;
1443                 break;
1444         case 'd':
1445         case 'g':
1446         case 'c':
1447                 while (*(++data) == ' ')
1448                         ;
1449                 i = 0;
1450                 MIPI_TRACE("****%d:%d\n", data-buf, count);
1451                 do {
1452                         if (i > 31) {
1453                                 MIPI_TRACE("payload entry is larger than 32\n");
1454                                 break;
1455                         }
1456                         sscanf(data, "%x,", (unsigned int *)(str + i)); /* -c 1,29,02,03,05,06,> pro */
1457                         data = strstr(data, ",");
1458                         if (data == NULL)
1459                                 break;
1460                         data++;
1461                         i++;
1462                 } while (1);
1463                 read_val = i;
1464                 i = 2;
1465                 while (i--) {
1466                         msleep(10);
1467                         if (command == 'd')
1468                                 rk32_mipi_dsi_send_packet(dsi1, str, read_val);
1469                         else
1470                                 rk32_mipi_dsi_send_packet(dsi1, str, read_val);
1471                 }
1472                 i = 1;
1473                 while (i--) {
1474                         msleep(1000);
1475                 }
1476                 break;
1477         default:
1478                 break;
1479         }
1480
1481 reg_proc_write_exit:
1482         kfree(buf);
1483         msleep(20);
1484         return count;
1485 }
1486
1487 int reg_proc_read1(struct file *file, char __user *buff, size_t count,
1488                                         loff_t *offp)
1489 {
1490         int i = 0;
1491         u32 val = 0;
1492
1493         for (i = VERSION; i < (VERSION + (0xdc<<16)); i += 4<<16) {
1494                 val = rk32_dsi_get_bits(dsi1, i);
1495                 MIPI_TRACE("%04x: %08x\n", i>>16, val);
1496                 msleep(1);
1497         }
1498
1499         MIPI_TRACE("\n");
1500         return -1;
1501 }
1502
1503 int reg_proc_open1(struct inode *inode, struct file *file)
1504 {
1505         return 0;
1506 }
1507
1508 int reg_proc_close1(struct inode *inode, struct file *file)
1509 {
1510         return 0;
1511 }
1512
1513 struct file_operations reg_proc_fops1 = {
1514         .owner = THIS_MODULE,
1515         .open = reg_proc_open1,
1516         .release = reg_proc_close1,
1517         .write = reg_proc_write1,
1518         .read = reg_proc_read1,
1519 };
1520 #endif
1521 #if 0/* def CONFIG_MIPI_DSI_LINUX */
1522 static irqreturn_t rk32_mipi_dsi_irq_handler(int irq, void *data)
1523 {
1524         printk("-------rk32_mipi_dsi_irq_handler-------\n");
1525         return IRQ_HANDLED;
1526 }
1527 #endif
1528
1529 #if 0
1530 static int dwc_phy_test_rd(struct dsi *dsi, unsigned char test_code)
1531 {
1532         int val = 0;
1533
1534         rk32_dsi_set_bits(dsi, 0x10000 | test_code, PHY_TEST_CTRL1);
1535         rk32_dsi_set_bits(dsi, 0x2, PHY_TEST_CTRL0);
1536         rk32_dsi_set_bits(dsi, 0x0, PHY_TEST_CTRL0);
1537
1538         val = rk32_dsi_get_bits(dsi, PHY_TEST_CTRL1);
1539         return val;
1540 }
1541 #endif
1542 static int rk32_dsi_enable(void)
1543 {
1544         MIPI_DBG("rk32_dsi_enable-------\n");
1545         rk_fb_get_prmry_screen(dsi0->screen.screen);
1546         dsi0->screen.lcdc_id = dsi0->screen.screen->lcdc_id;
1547         rk32_init_phy_mode(dsi0->screen.lcdc_id);
1548
1549         dsi_init(0, 0);
1550         if (rk_mipi_get_dsi_num() == 2)
1551                 dsi_init(1, 0);
1552
1553         rk_mipi_screen_standby(0);
1554
1555         /*
1556                 After the core reset, DPI waits for the first VSYNC active transition to start signal sampling, including
1557                 pixel data, and preventing image transmission in the middle of a frame.
1558         */
1559         dsi_is_enable(0, 0);
1560         if (rk_mipi_get_dsi_num() == 2)
1561                 dsi_is_enable(1, 0);
1562
1563         dsi_enable_video_mode(0, 1);
1564         if (rk_mipi_get_dsi_num() == 2)
1565                 dsi_enable_video_mode(1, 1);
1566
1567         dsi_is_enable(0, 1);
1568         if (rk_mipi_get_dsi_num() == 2)
1569                 dsi_is_enable(1, 1);
1570         return 0;
1571 }
1572
1573 #ifdef CONFIG_MIPI_DSI_LINUX
1574 static int rk32_dsi_disable(void)
1575 {
1576         MIPI_DBG("rk32_dsi_disable-------\n");
1577         rk_mipi_screen_standby(1);
1578         dsi_power_off(0);
1579         if (rk_mipi_get_dsi_num() == 2)
1580                 dsi_power_off(1);
1581         return 0;
1582 }
1583
1584 static struct rk_fb_trsm_ops trsm_dsi_ops = {
1585         .enable = rk32_dsi_enable,
1586         .disable = rk32_dsi_disable,
1587         .dsp_pwr_on = rk32_mipi_power_up_DDR,
1588         .dsp_pwr_off = rk32_mipi_power_down_DDR,
1589 };
1590 #endif
1591 static void rk32_init_phy_mode(int lcdc_id)
1592 {
1593         int val0 = 0, val1 = 0;
1594
1595         MIPI_DBG("rk32_init_phy_mode----------lcdc_id=%d\n", lcdc_id);
1596
1597         if (dsi0->ops.id == DWC_DSI_VERSION_RK312x)
1598                 return;
1599
1600         /* D-PHY mode select */
1601         if (rk_mipi_get_dsi_num() == 1) {
1602                 if (lcdc_id == 1)
1603                         /* 1'b1: VOP LIT output to DSI host0;1'b0: VOP BIG output to DSI host0 */
1604                         val0 = 0x1 << 22 | 0x1 << 6;
1605                 else
1606                         val0 = 0x1 << 22 | 0x0 << 6;
1607                 writel_relaxed(val0, RK_GRF_VIRT + RK3288_GRF_SOC_CON6);
1608         } else {
1609                 if (lcdc_id == 1) {
1610                         val0 = 0x1 << 25 | 0x1 <<  9 | 0x1 << 22 | 0x1 <<  6;
1611                         val1 = 0x1 << 31 | 0x1 << 30 | 0x0 << 15 | 0x1 << 14;
1612                 } else {
1613                         val0 = 0x1 << 25 | 0x0 <<  9 | 0x1 << 22 | 0x0 << 14;
1614                         val1 = 0x1 << 31 | 0x1 << 30 | 0x0 << 15 | 0x1 << 14;
1615                 }
1616                 writel_relaxed(val0, RK_GRF_VIRT + RK3288_GRF_SOC_CON6);
1617                 writel_relaxed(val1, RK_GRF_VIRT + RK3288_GRF_SOC_CON14);
1618         }
1619 }
1620
1621 #ifdef CONFIG_MIPI_DSI_LINUX
1622 static int rk32_mipi_power_down_DDR(void)
1623 {
1624         dsi_is_enable(0, 0);
1625         if (rk_mipi_get_dsi_num() == 2)
1626                 dsi_is_enable(1, 0);
1627         return 0;
1628 }
1629
1630 static int rk32_mipi_power_up_DDR(void)
1631 {
1632         dsi_is_enable(0, 0);
1633         if (rk_mipi_get_dsi_num() == 2)
1634                 dsi_is_enable(1, 0);
1635         dsi_enable_video_mode(0, 1);
1636         dsi_enable_video_mode(1, 1);
1637         dsi_is_enable(0, 1);
1638         if (rk_mipi_get_dsi_num() == 2)
1639                 dsi_is_enable(1, 1);
1640         return 0;
1641 }
1642
1643 struct dsi_type {
1644         char *label;
1645         u32 dsi_id;
1646 };
1647
1648 static struct dsi_type dsi_rk312x = {
1649         .label = "rk312-dsi",
1650         .dsi_id = DWC_DSI_VERSION_RK312x,
1651 };
1652
1653 static struct dsi_type dsi_rk32 = {
1654         .label = "rk32-dsi",
1655         .dsi_id = DWC_DSI_VERSION,
1656 };
1657
1658 static const struct of_device_id of_rk_mipi_dsi_match[] = {
1659         { .compatible = "rockchip,rk32-dsi", .data = &dsi_rk32},
1660         { .compatible = "rockchip,rk312x-dsi", .data = &dsi_rk312x},
1661         { /* Sentinel */ }
1662 };
1663
1664 static int rk32_mipi_dsi_probe(struct platform_device *pdev)
1665 {
1666         int ret = 0;
1667         static int id;
1668         struct dsi *dsi;
1669         struct mipi_dsi_ops *ops;
1670         struct rk_screen *screen;
1671         struct mipi_dsi_screen *dsi_screen;
1672         struct resource *res_host, *res_phy;
1673         const struct dsi_type *data;
1674         const struct of_device_id *of_id =
1675                         of_match_device(of_rk_mipi_dsi_match, &pdev->dev);
1676         if (!of_id) {
1677                 dev_err(&pdev->dev, "failed to match device\n");
1678                 return -ENODEV;
1679         }
1680         data = of_id->data;
1681
1682         dsi = devm_kzalloc(&pdev->dev, sizeof(struct dsi), GFP_KERNEL);
1683         if (!dsi) {
1684                 dev_err(&pdev->dev, "request struct dsi fail!\n");
1685                 return -ENOMEM;
1686         }
1687         dsi->ops.id = data->dsi_id;
1688         printk(KERN_INFO "%s\n", data->label);
1689
1690         if (dsi->ops.id == DWC_DSI_VERSION) {
1691                 res_host = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1692                 dsi->host.membase = devm_request_and_ioremap(&pdev->dev, res_host);
1693                 if (!dsi->host.membase) {
1694                         dev_err(&pdev->dev, "get resource mipi host membase fail!\n");
1695                         return -ENOMEM;
1696                 }
1697         } else if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
1698                 res_host = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mipi_dsi_host");
1699                 dsi->host.membase = devm_request_and_ioremap(&pdev->dev, res_host);
1700                 if (!dsi->host.membase) {
1701                         dev_err(&pdev->dev, "get resource mipi host membase fail!\n");
1702                         return -ENOMEM;
1703                 }
1704                 res_phy = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mipi_dsi_phy");
1705                 dsi->phy.membase = devm_request_and_ioremap(&pdev->dev, res_phy);
1706                 if (!dsi->phy.membase) {
1707                         dev_err(&pdev->dev, "get resource mipi phy membase fail!\n");
1708                         return -ENOMEM;
1709                 }
1710         }
1711
1712         dsi->phy.refclk  = devm_clk_get(&pdev->dev, "clk_mipi_24m");
1713         if (unlikely(IS_ERR(dsi->phy.refclk))) {
1714                 dev_err(&pdev->dev, "get clk_mipi_24m clock fail\n");
1715                 return PTR_ERR(dsi->phy.refclk);
1716         }
1717
1718         /* Get the mipi phy pclk */
1719         dsi->dsi_pclk = devm_clk_get(&pdev->dev, "pclk_mipi_dsi");
1720         if (unlikely(IS_ERR(dsi->dsi_pclk))) {
1721                 dev_err(&pdev->dev, "get pclk_mipi_dsi clock fail\n");
1722                 return PTR_ERR(dsi->dsi_pclk);
1723         }
1724
1725         if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
1726                 /* Get the mipi host pclk */
1727                 dsi->dsi_host_pclk = devm_clk_get(&pdev->dev, "pclk_mipi_dsi_host");
1728                 if (unlikely(IS_ERR(dsi->dsi_host_pclk))) {
1729                         dev_err(&pdev->dev, "get pclk_mipi_dsi_host clock fail\n");
1730                         return PTR_ERR(dsi->dsi_host_pclk);
1731                 }
1732                 /* Get the pd_vio AHB h2p bridge clock */
1733                 dsi->h2p_hclk = devm_clk_get(&pdev->dev, "hclk_vio_h2p");
1734                 if (unlikely(IS_ERR(dsi->h2p_hclk))) {
1735                         dev_err(&pdev->dev, "get hclk_vio_h2p clock fail\n");
1736                         return PTR_ERR(dsi->h2p_hclk);
1737                 }
1738         }
1739         dsi->dsi_pd = devm_clk_get(&pdev->dev, "pd_mipi_dsi");
1740         if (unlikely(IS_ERR(dsi->dsi_pd))) {
1741                 dev_err(&pdev->dev, "get pd_mipi_dsi clock fail\n");
1742                 return PTR_ERR(dsi->dsi_pd);
1743         }
1744         dsi->host.irq = platform_get_irq(pdev, 0);
1745         if (dsi->host.irq < 0) {
1746                 dev_err(&pdev->dev, "no irq resource?\n");
1747                 return dsi->host.irq;
1748         }
1749         /*
1750         ret = request_irq(dsi->host.irq, rk32_mipi_dsi_irq_handler, 0,dev_name(&pdev->dev), dsi);
1751         if (ret) {
1752                 dev_err(&pdev->dev, "request mipi_dsi irq fail\n");
1753                 return -EINVAL;
1754         }
1755         */
1756         printk("dsi->host.irq =%d\n", dsi->host.irq);
1757
1758         disable_irq(dsi->host.irq);
1759
1760         screen = devm_kzalloc(&pdev->dev, sizeof(struct rk_screen), GFP_KERNEL);
1761         if (!screen) {
1762                 dev_err(&pdev->dev, "request struct rk_screen fail!\n");
1763                 return -1;
1764         }
1765         rk_fb_get_prmry_screen(screen);
1766
1767         dsi->pdev = pdev;
1768         ops = &dsi->ops;
1769         ops->dsi = dsi;
1770
1771         ops->get_id = rk32_mipi_dsi_get_id,
1772         ops->dsi_send_packet = rk32_mipi_dsi_send_packet;
1773         ops->dsi_read_dcs_packet = rk32_mipi_dsi_read_dcs_packet,
1774         ops->dsi_enable_video_mode = rk32_mipi_dsi_enable_video_mode,
1775         ops->dsi_enable_command_mode = rk32_mipi_dsi_enable_command_mode,
1776         ops->dsi_enable_hs_clk = rk32_mipi_dsi_enable_hs_clk,
1777         ops->dsi_is_active = rk32_mipi_dsi_is_active,
1778         ops->dsi_is_enable = rk32_mipi_dsi_is_enable,
1779         ops->power_up = rk32_mipi_dsi_power_up,
1780         ops->power_down = rk32_mipi_dsi_power_down,
1781         ops->dsi_init = rk_mipi_dsi_init,
1782
1783         dsi_screen = &dsi->screen;
1784         dsi_screen->screen = screen;
1785         dsi_screen->type = screen->type;
1786         dsi_screen->face = screen->face;
1787         dsi_screen->lcdc_id = screen->lcdc_id;
1788         dsi_screen->screen_id = screen->screen_id;
1789         dsi_screen->pixclock = screen->mode.pixclock;
1790         dsi_screen->left_margin = screen->mode.left_margin;
1791         dsi_screen->right_margin = screen->mode.right_margin;
1792         dsi_screen->hsync_len = screen->mode.hsync_len;
1793         dsi_screen->upper_margin = screen->mode.upper_margin;
1794         dsi_screen->lower_margin = screen->mode.lower_margin;
1795         dsi_screen->vsync_len = screen->mode.vsync_len;
1796         dsi_screen->x_res = screen->mode.xres;
1797         dsi_screen->y_res = screen->mode.yres;
1798         dsi_screen->pin_hsync = screen->pin_hsync;
1799         dsi_screen->pin_vsync = screen->pin_vsync;
1800         dsi_screen->pin_den = screen->pin_den;
1801         dsi_screen->pin_dclk = screen->pin_dclk;
1802         dsi_screen->dsi_lane = rk_mipi_get_dsi_lane();
1803         /* dsi_screen->dsi_video_mode = screen->dsi_video_mode; */
1804         dsi_screen->dsi_lane = rk_mipi_get_dsi_lane();
1805         dsi_screen->hs_tx_clk = rk_mipi_get_dsi_clk();
1806         /* dsi_screen->lcdc_id = 1; */
1807
1808         dsi->dsi_id = id++;
1809
1810         sprintf(ops->name, "rk_mipi_dsi.%d", dsi->dsi_id);
1811         platform_set_drvdata(pdev, dsi);
1812
1813         ret = rk_mipi_dsi_probe(dsi);
1814         if (ret) {
1815                 dev_err(&pdev->dev, "rk mipi_dsi probe fail!\n");
1816                 dev_err(&pdev->dev, "%s\n", RK_MIPI_DSI_VERSION_AND_TIME);
1817                 return -1;
1818         }
1819
1820         if (id == 1) {
1821                 /*
1822                 if(!support_uboot_display())
1823                         rk32_init_phy_mode(dsi_screen->lcdc_id);
1824                 */
1825                 rk_fb_trsm_ops_register(&trsm_dsi_ops, SCREEN_MIPI);
1826 #ifdef MIPI_DSI_REGISTER_IO
1827                 debugfs_create_file("mipidsi0", S_IFREG | S_IRUGO, dsi->debugfs_dir, dsi,
1828                                                         &reg_proc_fops);
1829 #endif
1830                 dsi0 = dsi;
1831         } else {
1832                 dsi1 = dsi;
1833 #ifdef MIPI_DSI_REGISTER_IO
1834                 debugfs_create_file("mipidsi1", S_IFREG | S_IRUGO, dsi->debugfs_dir, dsi,
1835                                                         &reg_proc_fops1);
1836 #endif
1837         }
1838
1839         if (support_uboot_display()) {
1840                 clk_prepare_enable(dsi->phy.refclk);
1841                 clk_prepare_enable(dsi->dsi_pclk);
1842                 if (dsi->ops.id == DWC_DSI_VERSION_RK312x) {
1843                         clk_prepare_enable(dsi->dsi_host_pclk);
1844                         clk_prepare_enable(dsi->h2p_hclk);
1845                 }
1846                 clk_prepare_enable(dsi->dsi_pd);
1847                 udelay(10);
1848         }
1849         dev_info(&pdev->dev, "rk mipi_dsi probe success!\n");
1850         dev_info(&pdev->dev, "%s\n", RK_MIPI_DSI_VERSION_AND_TIME);
1851
1852         return ret;
1853 }
1854
1855 static struct platform_driver rk32_mipi_dsi_driver = {
1856         .probe = rk32_mipi_dsi_probe,
1857         .driver = {
1858                 .name = "rk32-mipi",
1859                 .owner = THIS_MODULE,
1860 #ifdef CONFIG_OF
1861                 .of_match_table = of_rk_mipi_dsi_match,
1862 #endif
1863         },
1864 };
1865
1866 static int __init rk32_mipi_dsi_init(void)
1867 {
1868         return platform_driver_register(&rk32_mipi_dsi_driver);
1869 }
1870 fs_initcall(rk32_mipi_dsi_init);
1871
1872 static void __exit rk32_mipi_dsi_exit(void)
1873 {
1874         platform_driver_unregister(&rk32_mipi_dsi_driver);
1875 }
1876 module_exit(rk32_mipi_dsi_exit);
1877 #endif