drivers/video/rockchip/screen/lcd_mipi.c

   1 /*
   2  * Copyright (C) 2014 ROCKCHIP, Inc.
   3  * drivers/video/rockchip/screen/lcd_mipi.c
   4  * author: libing@rock-chips.com
   5  * create date: 2014-04-10
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #ifndef CONFIG_LCD_MIPI
  17 #include <common.h>
  18 #endif
  19 #ifdef CONFIG_LCD_MIPI
  20 #include "../transmitter/mipi_dsi.h"
  21 #include <linux/delay.h>
  22 #endif
  23 #ifdef CONFIG_RK_3288_DSI_UBOOT
  24 #include <common.h>
  25 #include <asm/io.h>
  26 #include <errno.h>
  27 #include <malloc.h>
  28 #include <fdtdec.h>
  29 #include <errno.h>
  30 #include <asm/io.h>
  31 #include <asm/arch/rkplat.h>
  32 #include <lcd.h>
  33 #include "../transmitter/mipi_dsi.h"
  34 #endif
  35
  36 #ifdef CONFIG_RK_3288_DSI_UBOOT
  37 #define MIPI_SCREEN_DBG(x...)   /* printf(x) */
  38 #elif defined CONFIG_LCD_MIPI
  39 #define MIPI_SCREEN_DBG(x...)   /* printk(KERN_ERR x) */
  40 #else
  41 #define MIPI_SCREEN_DBG(x...)
  42 #endif
  43 #ifdef CONFIG_RK_3288_DSI_UBOOT
  44 DECLARE_GLOBAL_DATA_PTR;
  45 #define msleep(a) udelay(a * 1000)
  46 #define printk(x...)    /* printf(x) */
  47 #endif
  48 static struct mipi_screen *gmipi_screen;
  49
  50 static void rk_mipi_screen_pwr_disable(struct mipi_screen *screen)
  51 {
  52         if (screen->lcd_en_gpio != INVALID_GPIO) {
  53                 gpio_direction_output(screen->lcd_en_gpio, !screen->lcd_en_atv_val);
  54                 msleep(screen->lcd_en_delay);
  55         } else{
  56                 MIPI_SCREEN_DBG("lcd_en_gpio is null");
  57         }
  58
  59         if (screen->lcd_rst_gpio != INVALID_GPIO) {
  60
  61                 gpio_direction_output(screen->lcd_rst_gpio, !screen->lcd_rst_atv_val);
  62                 msleep(screen->lcd_rst_delay);
  63         } else {
  64                 MIPI_SCREEN_DBG("lcd_rst_gpio is null");
  65         }
  66 }
  67
  68 static void rk_mipi_screen_pwr_enable(struct mipi_screen *screen)
  69 {
  70         if (screen->lcd_en_gpio != INVALID_GPIO) {
  71                 gpio_direction_output(screen->lcd_en_gpio, !screen->lcd_en_atv_val);
  72                 msleep(screen->lcd_en_delay);
  73                 gpio_direction_output(screen->lcd_en_gpio, screen->lcd_en_atv_val);
  74                 msleep(screen->lcd_en_delay);
  75         } else
  76                 MIPI_SCREEN_DBG("lcd_en_gpio is null\n");
  77
  78         if (screen->lcd_rst_gpio != INVALID_GPIO) {
  79                 gpio_direction_output(screen->lcd_rst_gpio, !screen->lcd_rst_atv_val);
  80                 msleep (screen->lcd_rst_delay);
  81                 gpio_direction_output(screen->lcd_rst_gpio, screen->lcd_rst_atv_val);
  82                 msleep(screen->lcd_rst_delay);
  83         } else
  84                 MIPI_SCREEN_DBG("lcd_rst_gpio is null\n");
  85 }
  86
  87 static void rk_mipi_screen_cmd_init(struct mipi_screen *screen)
  88 {
  89         u8 len, i;
  90         u8 *cmds;
  91         struct list_head *screen_pos;
  92         struct mipi_dcs_cmd_ctr_list  *dcs_cmd;
  93 #ifdef CONFIG_RK_3288_DSI_UBOOT
  94         cmds = calloc(1, 0x400);
  95         if (!cmds) {
  96                 printf("request cmds fail!\n");
  97                 return;
  98         }
  99 #endif
 100
 101 #ifdef CONFIG_LCD_MIPI
 102         cmds = kmalloc(0x400, GFP_KERNEL);
 103         if (!cmds) {
 104                 printk("request cmds fail!\n");
 105                 return ;
 106         }
 107 #endif
 108         list_for_each(screen_pos, &screen->cmdlist_head) {
 109                 dcs_cmd = list_entry(screen_pos, struct mipi_dcs_cmd_ctr_list, list);
 110                 len = dcs_cmd->dcs_cmd.cmd_len + 1;
 111                 for (i = 1; i < len ; i++) {
 112                         cmds[i] = dcs_cmd->dcs_cmd.cmds[i-1];
 113                 }
 114                 MIPI_SCREEN_DBG("dcs_cmd.name:%s\n", dcs_cmd->dcs_cmd.name);
 115                 if (dcs_cmd->dcs_cmd.type == LPDT) {
 116                         cmds[0] = LPDT;
 117                         if (dcs_cmd->dcs_cmd.dsi_id == 0) {
 118                                 MIPI_SCREEN_DBG("dcs_cmd.dsi_id == 0 line=%d\n", __LINE__);
 119                                 dsi_send_packet(0, cmds, len);
 120                         } else if (dcs_cmd->dcs_cmd.dsi_id == 1) {
 121                                 MIPI_SCREEN_DBG("dcs_cmd.dsi_id == 1 line=%d\n", __LINE__);
 122                                 dsi_send_packet(1, cmds, len);
 123                         } else if (dcs_cmd->dcs_cmd.dsi_id == 2) {
 124                                 MIPI_SCREEN_DBG("dcs_cmd.dsi_id == 2 line=%d\n", __LINE__);
 125                                 dsi_send_packet(0, cmds, len);
 126                                 dsi_send_packet(1, cmds, len);
 127                         } else {
 128                                 MIPI_SCREEN_DBG("dsi is err.\n");
 129                         }
 130                         msleep(dcs_cmd->dcs_cmd.delay);
 131                 } else if (dcs_cmd->dcs_cmd.type == HSDT) {
 132                         cmds[0] = HSDT;
 133                         if (dcs_cmd->dcs_cmd.dsi_id == 0) {
 134                                 MIPI_SCREEN_DBG("dcs_cmd.dsi_id == 0 line=%d\n", __LINE__);
 135                                 dsi_send_packet(0, cmds, len);
 136                         } else if (dcs_cmd->dcs_cmd.dsi_id == 1) {
 137                                 MIPI_SCREEN_DBG("dcs_cmd.dsi_id == 1 line=%d\n", __LINE__);
 138                                 dsi_send_packet(1, cmds, len);
 139                         } else if (dcs_cmd->dcs_cmd.dsi_id == 2) {
 140                                 MIPI_SCREEN_DBG("dcs_cmd.dsi_id == 2 line=%d\n", __LINE__);
 141                                 dsi_send_packet(0, cmds, len);
 142                                 dsi_send_packet(1, cmds, len);
 143                         } else {
 144                                 MIPI_SCREEN_DBG("dsi is err.");
 145                         }
 146                         msleep(dcs_cmd->dcs_cmd.delay);
 147                 } else
 148                         MIPI_SCREEN_DBG("cmd type err.\n");
 149         }
 150
 151 #ifdef CONFIG_RK_3288_DSI_UBOOT
 152         free(cmds);
 153 #endif
 154 #ifdef CONFIG_LCD_MIPI
 155         kfree(cmds);
 156 #endif
 157 }
 158
 159 int rk_mipi_screen(void)
 160 {
 161         u8 dcs[16] = {0}, rk_dsi_num;
 162         rk_dsi_num = gmipi_screen->mipi_dsi_num;
 163         if (gmipi_screen->screen_init == 0) {
 164                 rk_mipi_screen_pwr_enable(gmipi_screen);
 165                 dsi_enable_hs_clk(0, 1);
 166                 if (rk_dsi_num == 2) {
 167                         dsi_enable_hs_clk(1, 1);
 168                 }
 169
 170                 dsi_enable_video_mode(0, 0);
 171                 if (rk_dsi_num == 2) {
 172                         dsi_enable_video_mode(1, 0);
 173                 }
 174
 175                 dsi_enable_command_mode(0, 1);
 176                 if (rk_dsi_num == 2) {
 177                         dsi_enable_command_mode(1, 1);
 178                 }
 179
 180                 dcs[0] = LPDT;
 181                 dcs[1] = DTYPE_DCS_SWRITE_0P;
 182                 dcs[2] = dcs_exit_sleep_mode;
 183                 dsi_send_packet(0, dcs, 3);
 184                 if (rk_dsi_num == 2)
 185                         dsi_send_packet(1, dcs, 3);
 186
 187                 msleep(20);
 188
 189                 dcs[0] = LPDT;
 190                 dcs[1] = DTYPE_DCS_SWRITE_0P;
 191                 dcs[2] = dcs_set_display_on;
 192                 dsi_send_packet(0, dcs, 3);
 193                 if (rk_dsi_num == 2)
 194                         dsi_send_packet(1, dcs, 3);
 195
 196                 msleep(20);
 197
 198                 dsi_enable_command_mode(0, 0);
 199                 if (rk_dsi_num == 2) {
 200                         dsi_enable_command_mode(1, 0);
 201                 }
 202
 203                 dsi_enable_video_mode(0, 1);
 204                 if (rk_dsi_num == 2) {
 205                         dsi_enable_video_mode(1, 1);
 206                 }
 207         } else {
 208                 rk_mipi_screen_pwr_enable(gmipi_screen);
 209
 210                 dsi_enable_hs_clk(0, 1);
 211                 if (rk_dsi_num == 2) {
 212                         dsi_enable_hs_clk(1, 1);
 213                 }
 214
 215                 dsi_enable_video_mode(0, 0);
 216                 if (rk_dsi_num == 2) {
 217                         dsi_enable_video_mode(1, 0);
 218                 }
 219
 220                 dsi_enable_command_mode(0, 1);
 221                 if (rk_dsi_num == 2) {
 222                         dsi_enable_command_mode(1, 1);
 223                 }
 224
 225                 rk_mipi_screen_cmd_init(gmipi_screen);
 226
 227                 dsi_enable_command_mode(0, 0);
 228                 if (rk_dsi_num == 2) {
 229                         dsi_enable_command_mode(1, 0);
 230                 }
 231
 232                 dsi_enable_video_mode(0, 1);
 233                 if (rk_dsi_num == 2) {
 234                         dsi_enable_video_mode(1, 1);
 235                 }
 236         }
 237
 238         MIPI_SCREEN_DBG("++++++++++++++++%s:%d\n", __func__, __LINE__);
 239         return 0;
 240 }
 241
 242 int rk_mipi_screen_standby(u8 enable)
 243 {
 244         u8 dcs[16] = {0}, rk_dsi_num;
 245         rk_dsi_num = gmipi_screen->mipi_dsi_num;
 246
 247         if (dsi_is_active(0) != 1)
 248                 return -1;
 249
 250         if (rk_dsi_num == 2)
 251                 if ((dsi_is_active(0) != 1) || (dsi_is_active(1) != 1))
 252                         return -1;
 253
 254         if (enable) {
 255                 /* below is changeable */
 256                 dcs[0] = LPDT;
 257                 dcs[1] = DTYPE_DCS_SWRITE_0P;
 258                 dcs[2] = dcs_set_display_off;
 259                 dsi_send_packet(0, dcs, 3);
 260                 if (rk_dsi_num == 2)
 261                         dsi_send_packet(1, dcs, 3);
 262
 263                 msleep(30);
 264
 265                 dcs[0] = LPDT;
 266                 dcs[1] = DTYPE_DCS_SWRITE_0P;
 267                 dcs[2] = dcs_enter_sleep_mode;
 268                 dsi_send_packet(0, dcs, 3);
 269                 if (rk_dsi_num == 2)
 270                         dsi_send_packet(1, dcs, 3);
 271
 272                 msleep(100);
 273                 rk_mipi_screen_pwr_disable(gmipi_screen);
 274                 MIPI_SCREEN_DBG("++++enable++++++++++++%s:%d\n", __func__, __LINE__);
 275         } else {
 276                 rk_mipi_screen();
 277         }
 278         return 0;
 279 }
 280 #ifdef CONFIG_LCD_MIPI
 281 static int rk_mipi_screen_init_dt(struct mipi_screen *screen)
 282 {
 283         struct device_node *childnode, *grandchildnode, *root;
 284         struct mipi_dcs_cmd_ctr_list *dcs_cmd;
 285         struct list_head *pos;
 286         struct property *prop;
 287         enum of_gpio_flags flags;
 288         u32 value, i, debug, gpio, ret, cmds[25], length;
 289
 290         memset(screen, 0, sizeof(*screen));
 291
 292         INIT_LIST_HEAD(&screen->cmdlist_head);
 293
 294         childnode = of_find_node_by_name(NULL, "mipi_dsi_init");
 295         if (!childnode) {
 296                 MIPI_SCREEN_DBG("%s: Can not get child => mipi_init.\n", __func__);
 297         } else {
 298                 ret = of_property_read_u32(childnode, "rockchip,screen_init", &value);
 299                 if (ret) {
 300                         MIPI_SCREEN_DBG("%s: Can not read property: screen_init.\n", __func__);
 301                 } else {
 302                         if ((value != 0) && (value != 1)) {
 303                                 printk("err: rockchip,mipi_dsi_init not match.\n");
 304                                 return -1;
 305                         } else
 306                                 screen->screen_init = value ;
 307
 308                         MIPI_SCREEN_DBG("%s: lcd->screen_init = %d.\n", __func__, screen->screen_init);
 309                 }
 310
 311                 ret = of_property_read_u32(childnode, "rockchip,dsi_lane", &value);
 312                 if (ret) {
 313                         MIPI_SCREEN_DBG("%s: Can not read property: dsi_lane.\n", __func__);
 314                 } else {
 315                         screen->dsi_lane = value;
 316                         MIPI_SCREEN_DBG("%s: mipi_lcd->dsi_lane = %d.\n", __func__, screen->dsi_lane);
 317                 }
 318
 319                 ret = of_property_read_u32(childnode, "rockchip,dsi_hs_clk", &value);
 320                 if (ret) {
 321                         MIPI_SCREEN_DBG("%s: Can not read property: dsi_hs_clk.\n", __func__);
 322                 } else {
 323                         if ((value <= 90) || (value >= 1500)) {
 324                                 printk("err: rockchip,hs_tx_clk not match.");
 325                                 return -1;
 326                         } else {
 327                                 screen->hs_tx_clk = value*MHz;
 328                         }
 329
 330                         MIPI_SCREEN_DBG("%s: lcd->screen->hs_tx_clk = %d.\n", __func__, screen->hs_tx_clk);
 331                 }
 332
 333                 ret = of_property_read_u32(childnode, "rockchip,mipi_dsi_num", &value);
 334                 if (ret) {
 335                         MIPI_SCREEN_DBG("%s: Can not read property: mipi_dsi_num.\n", __func__);
 336                 } else {
 337                         if ((value != 1) && (value != 2)) {
 338                                 printk("err: rockchip,mipi_dsi_num not match.\n");
 339                                 return -1;
 340                         } else {
 341                                 screen->mipi_dsi_num = value ;
 342                         }
 343
 344                         MIPI_SCREEN_DBG("%s: lcd->screen.mipi_dsi_num = %d.\n", __func__, screen->mipi_dsi_num);
 345                 }
 346         }
 347
 348         childnode = of_find_node_by_name(NULL, "mipi_power_ctr");
 349         if (!childnode) {
 350                 screen->lcd_rst_gpio = INVALID_GPIO;
 351                 screen->lcd_en_gpio = INVALID_GPIO;
 352                 MIPI_SCREEN_DBG("%s: Can not get child => mipi_power_ctr.\n", __func__);
 353         } else {
 354                 grandchildnode = of_get_child_by_name(childnode, "mipi_lcd_rst");
 355                 if (!grandchildnode) {
 356                         screen->lcd_rst_gpio = INVALID_GPIO;
 357                         MIPI_SCREEN_DBG("%s: Can not read property: mipi_lcd_rst.\n", __func__);
 358                 } else {
 359                         ret = of_property_read_u32(grandchildnode, "rockchip,delay", &value);
 360                         if (ret) {
 361                                 MIPI_SCREEN_DBG("%s: Can not read property: delay.\n", __func__);
 362                         } else {
 363                                 screen->lcd_rst_delay = value;
 364                                 MIPI_SCREEN_DBG("%s: lcd->screen->lcd_rst_delay = %d.\n", __func__, screen->lcd_rst_delay);
 365                         }
 366
 367                         gpio = of_get_named_gpio_flags(grandchildnode, "rockchip,gpios", 0, &flags);
 368                         if (!gpio_is_valid(gpio)) {
 369                                 MIPI_SCREEN_DBG("rest: Can not read property: %s->gpios.\n", __func__);
 370                         }
 371
 372                         ret = gpio_request(gpio, "mipi_lcd_rst");
 373                         if (ret) {
 374                                 screen->lcd_rst_gpio = INVALID_GPIO;
 375                                 MIPI_SCREEN_DBG("request mipi_lcd_rst gpio fail:%d\n", gpio);
 376                                 return -1;
 377                         }
 378
 379                         screen->lcd_rst_gpio = gpio;
 380                         screen->lcd_rst_atv_val = (flags == GPIO_ACTIVE_HIGH) ? 1:0;
 381
 382                         MIPI_SCREEN_DBG("lcd->lcd_rst_gpio=%d,dsi->lcd_rst_atv_val=%d\n", screen->lcd_rst_gpio, screen->lcd_rst_atv_val);
 383                 }
 384
 385                 grandchildnode = of_get_child_by_name(childnode, "mipi_lcd_en");
 386                 if (!grandchildnode) {
 387                         screen->lcd_en_gpio = INVALID_GPIO;
 388                         MIPI_SCREEN_DBG("%s: Can not read property: mipi_lcd_en.\n", __func__);
 389                 } else {
 390                         ret = of_property_read_u32(grandchildnode, "rockchip,delay", &value);
 391                         if (ret) {
 392                                 MIPI_SCREEN_DBG("%s: Can not read property: mipi_lcd_en-delay.\n", __func__);
 393                         } else {
 394                                 screen->lcd_en_delay = value;
 395                                 MIPI_SCREEN_DBG("%s: lcd->screen.lcd_en_delay = %d.\n", __func__, screen->lcd_en_delay);
 396                         }
 397
 398                         gpio = of_get_named_gpio_flags(grandchildnode, "rockchip,gpios", 0, &flags);
 399                         if (!gpio_is_valid(gpio)) {
 400                                 MIPI_SCREEN_DBG("rest: Can not read property: %s->gpios.\n", __func__);
 401                         }
 402
 403                         ret = gpio_request(gpio, "mipi_lcd_en");
 404                         if (ret) {
 405                                 screen->lcd_en_gpio = INVALID_GPIO;
 406                                 MIPI_SCREEN_DBG("request mipi_lcd_en gpio fail:%d\n", gpio);
 407                                 return -1;
 408                         }
 409                         screen->lcd_en_gpio = gpio;
 410                         screen->lcd_en_atv_val = (flags == GPIO_ACTIVE_HIGH) ? 1:0;
 411                         MIPI_SCREEN_DBG("dsi->lcd_en_gpio=%d, dsi->screen.lcd_en_atv_val=%d\n", screen->lcd_en_gpio, screen->lcd_en_atv_val);
 412                 }
 413         }
 414
 415         root = of_find_node_by_name(NULL, "screen-on-cmds");
 416         if (!root) {
 417                 MIPI_SCREEN_DBG("can't find screen-on-cmds node\n");
 418         } else {
 419                 for_each_child_of_node(root, childnode) {
 420                         dcs_cmd = kmalloc(sizeof(struct mipi_dcs_cmd_ctr_list), GFP_KERNEL);
 421                         strcpy(dcs_cmd->dcs_cmd.name, childnode->name);
 422
 423                         prop = of_find_property(childnode, "rockchip,cmd", &length);
 424                         if (!prop) {
 425                                 MIPI_SCREEN_DBG("Can not read property: cmds\n");
 426                                 return -EINVAL;
 427                         }
 428
 429                         MIPI_SCREEN_DBG("\n childnode->name =%s:length=%d\n", childnode->name, (length / sizeof(u32)));
 430
 431                         ret = of_property_read_u32_array(childnode,  "rockchip,cmd", cmds, (length / sizeof(u32)));
 432                         if (ret < 0) {
 433                                 MIPI_SCREEN_DBG("%s: Can not read property: %s--->cmds\n", __func__, childnode->name);
 434                                 return ret;
 435                         } else {
 436                                 dcs_cmd->dcs_cmd.cmd_len =  length / sizeof(u32);
 437                                 for (i = 0; i < (length / sizeof(u32)); i++) {
 438                                         MIPI_SCREEN_DBG("cmd[%d]=%02x£¬", i+1, cmds[i]);
 439                                         dcs_cmd->dcs_cmd.cmds[i] = cmds[i];
 440                                 }
 441
 442                                 MIPI_SCREEN_DBG("dcs_cmd->dcs_cmd.cmd_len=%d\n", dcs_cmd->dcs_cmd.cmd_len);
 443                         }
 444                         ret = of_property_read_u32(childnode, "rockchip,dsi_id", &value);
 445                         if (ret) {
 446                                 MIPI_SCREEN_DBG("%s: Can not read property: %s--->cmd_type\n", __func__, childnode->name);
 447                         } else {
 448                                 if (screen->mipi_dsi_num == 1) {
 449                                         if (value != 0) {
 450                                                 printk("err: rockchip,dsi_id not match.\n");
 451                                         } else {
 452                                                 dcs_cmd->dcs_cmd.dsi_id = value;
 453                                         }
 454                                 } else {
 455                                         if ((value < 0) || (value > 2))
 456                                                 printk("err: rockchip,dsi_id not match.\n");
 457                                         else
 458                                                 dcs_cmd->dcs_cmd.dsi_id = value;
 459                                 }
 460                         }
 461
 462                         ret = of_property_read_u32(childnode, "rockchip,cmd_type", &value);
 463                         if (ret) {
 464                                 MIPI_SCREEN_DBG("%s: Can not read property: %s--->cmd_type\n", __func__, childnode->name);
 465                         } else {
 466                                 if ((value != 0) && (value != 1)) {
 467                                         printk("err: rockchip, cmd_type not match.\n");
 468                                 } else {
 469                                         dcs_cmd->dcs_cmd.type = value;
 470                                 }
 471                         }
 472
 473                         ret = of_property_read_u32(childnode, "rockchip,cmd_delay", &value);
 474                         if (ret)
 475                                 MIPI_SCREEN_DBG("%s: Can not read property: %s--->cmd_delay\n", __func__, childnode->name);
 476                         else
 477                                 dcs_cmd->dcs_cmd.delay = value;
 478
 479                         list_add_tail(&dcs_cmd->list, &screen->cmdlist_head);
 480                 }
 481         }
 482         ret = of_property_read_u32(root, "rockchip,cmd_debug", &debug);
 483         if (ret) {
 484                 MIPI_SCREEN_DBG("%s: Can not read property: rockchip,cmd_debug.\n", __func__);
 485         } else {
 486                 if (debug) {
 487                         list_for_each(pos, &screen->cmdlist_head) {
 488                                 dcs_cmd = list_entry(pos, struct mipi_dcs_cmd_ctr_list, list);
 489                                 printk("\n dcs_name:%s,dcs_type:%d,side_id:%d,cmd_len:%d,delay:%d\n\n",
 490                                         dcs_cmd->dcs_cmd.name,
 491                                         dcs_cmd->dcs_cmd.type,
 492                                         dcs_cmd->dcs_cmd.dsi_id,
 493                                         dcs_cmd->dcs_cmd.cmd_len,
 494                                         dcs_cmd->dcs_cmd.delay);
 495                                 for (i = 0; i < (dcs_cmd->dcs_cmd.cmd_len); i++) {
 496                                         printk("[%d]=%02x,", i+1, dcs_cmd->dcs_cmd.cmds[i]);
 497                                 }
 498                         }
 499                 } else {
 500                         MIPI_SCREEN_DBG("---close cmd debug---\n");
 501                 }
 502         }
 503         return 0;
 504 }
 505 #endif
 506 int rk_mipi_get_dsi_num(void)
 507 {
 508         return gmipi_screen->mipi_dsi_num;
 509 }
 510 #ifdef CONFIG_LCD_MIPI
 511 EXPORT_SYMBOL(rk_mipi_get_dsi_num);
 512 #endif
 513 int rk_mipi_get_dsi_lane(void)
 514 {
 515         return gmipi_screen->dsi_lane;
 516 }
 517 #ifdef CONFIG_LCD_MIPI
 518 EXPORT_SYMBOL(rk_mipi_get_dsi_lane);
 519 #endif
 520
 521 int rk_mipi_get_dsi_clk(void)
 522 {
 523         return gmipi_screen->hs_tx_clk;
 524 }
 525 #ifdef CONFIG_LCD_MIPI
 526 EXPORT_SYMBOL(rk_mipi_get_dsi_clk);
 527 #endif
 528 #ifdef CONFIG_RK_3288_DSI_UBOOT
 529 #ifdef CONFIG_OF_LIBFDT
 530 static int rk_mipi_screen_init_dt(struct mipi_screen *screen)
 531 {
 532         struct mipi_dcs_cmd_ctr_list *dcs_cmd;
 533         u32 i, cmds[20];
 534         int length;
 535         int err;
 536         int node;
 537         const void *blob;
 538         struct fdt_gpio_state gpio_val;
 539         int noffset;
 540
 541         INIT_LIST_HEAD(&screen->cmdlist_head);
 542
 543         blob = gd->fdt_blob; /* getenv_hex("fdtaddr", 0); */
 544         node = fdtdec_next_compatible(blob, 0, COMPAT_ROCKCHIP_MIPI_INIT);
 545         if (node < 0) {
 546                 MIPI_SCREEN_DBG("Can not get node of COMPAT_ROCKCHIP_MIPI_INIT\n");
 547         }
 548         screen->screen_init = fdtdec_get_int(blob, node, "rockchip,screen_init", -1);
 549         if (screen->screen_init < 0) {
 550                 MIPI_SCREEN_DBG("Can not get screen_init\n");
 551         }
 552         screen->dsi_lane = fdtdec_get_int(blob, node, "rockchip,dsi_lane", -1);
 553         if (screen->dsi_lane < 0) {
 554                 MIPI_SCREEN_DBG("Can not get dsi_lane\n");
 555         }
 556         screen->hs_tx_clk = fdtdec_get_int(blob, node, "rockchip,dsi_hs_clk", -1);
 557         if (screen->hs_tx_clk < 0) {
 558                 MIPI_SCREEN_DBG("Can not get dsi_hs_clk\n");
 559         } else {
 560                 screen->hs_tx_clk = screen->hs_tx_clk*MHZ;
 561         }
 562         screen->mipi_dsi_num = fdtdec_get_int(blob, node, "rockchip,mipi_dsi_num", -1);
 563         if (screen->mipi_dsi_num < 0) {
 564                 MIPI_SCREEN_DBG("Can't get mipi_dsi_num\n");
 565         }
 566 #if 0
 567         node = fdtdec_next_compatible(blob, 0, COMPAT_ROCKCHIP_MIPI_PWR);
 568         if (node < 0) {
 569                 printf("Can not get node of COMPAT_ROCKCHIP_MIPI_PWR\n");
 570         }
 571 #endif
 572
 573 #if 0
 574 /*get the lcd rst status
 575         handle = fdt_getprop_u32_default(blob, "/mipi_power_ctr", "mipi_lcd_rst", -1);
 576         node = fdt_node_offset_by_phandle(blob, handle);
 577 */
 578         node = fdtdec_next_compatible(blob, 0, COMPAT_ROCKCHIP_MIPI_PWR);
 579         if (node < 0) {
 580                 printf("Can not get node of COMPAT_ROCKCHIP_MIPI_PWR\n");
 581         } else {
 582                 subnode = fdtdec_next_compatible_subnode(blob, node,
 583                                 COMPAT_ROCKCHIP_MIPI_LCD_RST, &depth);
 584                 if (subnode <= 0) {
 585                         screen->lcd_rst_gpio = INVALID_GPIO;
 586                         printf("Can't get pin of mipi_lcd_rst\n");
 587                 } else {
 588                         err = fdtdec_decode_gpio(blob, subnode, "rockchip,gpios", &gpio_val);
 589                         gpio_val.gpio = rk_gpio_base_to_bank(gpio_val.gpio & RK_GPIO_BANK_MASK) | (gpio_val.gpio & RK_GPIO_PIN_MASK);
 590                         if (err < 0) {
 591                                 screen->lcd_rst_gpio = INVALID_GPIO;
 592                                 printf("Can't find GPIO rst\n");
 593                         } else {
 594                                 screen->lcd_rst_gpio = gpio_val.gpio;
 595                                 screen->lcd_rst_atv_val = !(gpio_val.flags & OF_GPIO_ACTIVE_LOW);
 596                         }
 597                         screen->lcd_rst_delay = fdtdec_get_int(blob, subnode, "rockchip,delay", -1);
 598                         if (screen->lcd_rst_delay < 0) {
 599                                 printf("Can't get delay of rst delay\n");
 600                         }
 601                         printf("Get lcd rst gpio and delay successfully!\n");
 602                 }
 603         }
 604 #endif
 605         /* get the lcd rst & en status */
 606         node = fdtdec_next_compatible(blob, 0, COMPAT_ROCKCHIP_MIPI_PWR);
 607         if (node < 0) {
 608                 MIPI_SCREEN_DBG("Can not get node of COMPAT_ROCKCHIP_MIPI_PWR\n");
 609         } else {
 610 #if 0
 611                 noffset = fdt_first_subnode(blob, node);
 612                 const char *name = fdt_get_name(blob, noffset, NULL);
 613                 printf("XJH_DEBUG1:%s\n", name);
 614                 noffset = fdt_next_subnode(blob, noffset);
 615                 const char *name1 = fdt_get_name(blob, noffset, NULL);
 616                 printf("XJH_DEBUG2:%s\n", name1);
 617 #endif
 618                 for (noffset = fdt_first_subnode(blob, node);
 619                 noffset >= 0;
 620                 noffset = fdt_next_subnode(blob, noffset)) {
 621                         if (0 == fdt_node_check_compatible(blob, noffset, "rockchip,lcd_rst")) {
 622                                 err = fdtdec_decode_gpio(blob, noffset, "rockchip,gpios", &gpio_val);
 623                                 gpio_val.gpio = rk_gpio_base_to_bank(gpio_val.gpio & RK_GPIO_BANK_MASK) | (gpio_val.gpio & RK_GPIO_PIN_MASK);
 624                                 if (err < 0) {
 625                                         screen->lcd_rst_gpio = INVALID_GPIO;
 626                                         MIPI_SCREEN_DBG("Can't find GPIO rst\n");
 627                                 } else {
 628                                         screen->lcd_rst_gpio = gpio_val.gpio;
 629                                         screen->lcd_rst_atv_val = !(gpio_val.flags & OF_GPIO_ACTIVE_LOW);
 630                                 }
 631                                 screen->lcd_rst_delay = fdtdec_get_int(blob, noffset, "rockchip,delay", -1);
 632                                 if (screen->lcd_rst_delay < 0) {
 633                                         MIPI_SCREEN_DBG("Can't get delay of rst delay\n");
 634                                 }
 635                                 MIPI_SCREEN_DBG("Get lcd rst gpio and delay successfully!\n");
 636                         }
 637                         if (0 == fdt_node_check_compatible(blob, noffset, "rockchip,lcd_en")) {
 638                                 err = fdtdec_decode_gpio(blob, noffset, "rockchip,gpios", &gpio_val);
 639                                 gpio_val.gpio = rk_gpio_base_to_bank(gpio_val.gpio & RK_GPIO_BANK_MASK) | (gpio_val.gpio & RK_GPIO_PIN_MASK);
 640                                 if (err < 0) {
 641                                         screen->lcd_en_gpio = INVALID_GPIO;
 642                                         MIPI_SCREEN_DBG("Can't find GPIO en\n");
 643                                 } else {
 644                                         screen->lcd_en_gpio = gpio_val.gpio;
 645                                         screen->lcd_en_atv_val = !(gpio_val.flags & OF_GPIO_ACTIVE_LOW);
 646                                 }
 647                                 screen->lcd_en_delay = fdtdec_get_int(blob, noffset, "rockchip,delay", -1);
 648                                 if (screen->lcd_en_delay < 0) {
 649                                         MIPI_SCREEN_DBG("Can't get delay of lcd_en delay\n");
 650                                 }
 651                                 MIPI_SCREEN_DBG("Get lcd en gpio and delay successfully:delay %d!\n", screen->lcd_en_delay);
 652                         }
 653                 }
 654         }
 655
 656         /*get the initial command list*/
 657         node = fdtdec_next_compatible(blob, 0, COMPAT_ROCKCHIP_MIPI_SONCMDS);
 658         if (node < 0) {
 659                 MIPI_SCREEN_DBG("Can not get node of COMPAT_ROCKCHIP_MIPI_SONCMDS\n");
 660         } else {
 661                 for (noffset = fdt_first_subnode(blob, node);
 662                 noffset >= 0;
 663                 noffset = fdt_next_subnode(blob, noffset)) {
 664
 665                         MIPI_SCREEN_DBG("build MIPI LCD init cmd tables\n");
 666                         /*
 667                         subnode = fdtdec_next_compatible_subnode(blob, node,
 668                                         COMPAT_ROCKCHIP_MIPI_ONCMDS, &depth);
 669                         if (noffset < 0)
 670                                 break;
 671                         */
 672                         dcs_cmd = calloc(1, sizeof(struct mipi_dcs_cmd_ctr_list));
 673                         /* node = fdt_node_offset_by_phandle(blob, handle); */
 674                         strcpy(dcs_cmd->dcs_cmd.name, fdt_get_name(blob, noffset, NULL));
 675                         MIPI_SCREEN_DBG("%s\n", dcs_cmd->dcs_cmd.name);
 676                         dcs_cmd->dcs_cmd.type = fdtdec_get_int(blob, noffset, "rockchip,cmd_type", -1);
 677                         MIPI_SCREEN_DBG("dcs_cmd.type=%02x\n", dcs_cmd->dcs_cmd.type);
 678                         dcs_cmd->dcs_cmd.dsi_id = fdtdec_get_int(blob, noffset, "rockchip,dsi_id", -1);
 679                         MIPI_SCREEN_DBG("dcs_cmd.dsi_id=%02x\n", dcs_cmd->dcs_cmd.dsi_id);
 680                         fdt_getprop(blob, noffset, "rockchip,cmd", &length);
 681                         dcs_cmd->dcs_cmd.cmd_len = length / sizeof(u32) ;
 682                         err = fdtdec_get_int_array(blob, noffset, "rockchip,cmd", cmds, dcs_cmd->dcs_cmd.cmd_len);
 683                         MIPI_SCREEN_DBG("length=%d,cmd_len = %d  err = %d\n", length, dcs_cmd->dcs_cmd.cmd_len, err);
 684                         for (i = 0; i < (length / sizeof(u32)); i++) {
 685                                 MIPI_SCREEN_DBG("cmd[%d]=0x%08x, ", i+1, cmds[i]);
 686                                 dcs_cmd->dcs_cmd.cmds[i] = cmds[i];
 687                         }
 688                         MIPI_SCREEN_DBG("\n");
 689                         dcs_cmd->dcs_cmd.delay = fdtdec_get_int(blob, noffset, "rockchip,cmd_delay", -1);
 690                         MIPI_SCREEN_DBG("dcs_cmd.delay=%d\n", dcs_cmd->dcs_cmd.delay);
 691                         list_add_tail(&dcs_cmd->list, &screen->cmdlist_head);
 692                 }
 693         }
 694         return 0;
 695 }
 696 #endif /* CONFIG_OF_LIBFDT */
 697
 698 int rk_mipi_screen_probe(void)
 699 {
 700         int ret = 0;
 701         gmipi_screen = calloc(1, sizeof(struct mipi_screen));
 702         if (!gmipi_screen) {
 703                 printf("request struct screen fail!\n");
 704                 return -ENOMEM;
 705         }
 706 #ifdef CONFIG_OF_LIBFDT
 707         ret = rk_mipi_screen_init_dt(gmipi_screen);
 708         if (ret < 0) {
 709                 printf(" rk_mipi_screen_init_dt fail!\n");
 710                 return -1;
 711         }
 712 #endif /* CONFIG_OF_LIBFDT */
 713
 714         MIPI_SCREEN_DBG("---rk_mipi_screen_probe--end\n");
 715         return 0;
 716 }
 717
 718 #endif /* CONFIG_RK_3288_DSI_UBOOT */
 719 #ifdef CONFIG_LCD_MIPI
 720 static int __init rk_mipi_screen_probe(struct platform_device *pdev)
 721 {
 722         static int ret;
 723
 724         gmipi_screen = devm_kzalloc(&pdev->dev, sizeof(struct mipi_screen), GFP_KERNEL);
 725         if (!gmipi_screen) {
 726                 dev_err(&pdev->dev, "request struct screen fail!\n");
 727                 return -ENOMEM;
 728         }
 729
 730         ret = rk_mipi_screen_init_dt(gmipi_screen);
 731         if (ret < 0) {
 732                 dev_err(&pdev->dev, " rk_mipi_screen_init_dt fail!\n");
 733                 return -1;
 734         }
 735
 736         MIPI_SCREEN_DBG("---rk_mipi_screen_probe--end\n");
 737         return 0;
 738 }
 739
 740 static struct platform_driver mipi_screen_platform_driver = {
 741         .driver = {
 742                 .name = "rk_mipi_screen",
 743         },
 744 };
 745
 746 static int __init rk_mipi_screen_init(void)
 747 {
 748         platform_device_register_simple("rk_mipi_screen", -1, NULL, 0);
 749         return platform_driver_probe(&mipi_screen_platform_driver, rk_mipi_screen_probe);
 750 }
 751
 752 static void __exit rk_mipi_screen_exit(void)
 753 {
 754         platform_driver_unregister(&mipi_screen_platform_driver);
 755 }
 756
 757 subsys_initcall_sync(rk_mipi_screen_init);
 758 module_exit(rk_mipi_screen_exit);
 759 #endif