drivers/video/rockchip/rk_fb.c

   1 /*
   2  * drivers/video/rockchip/rk_fb.c
   3  *
   4  * Copyright (C) ROCKCHIP, Inc.
   5  * Author:yxj<yxj@rock-chips.com>
   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 #include <linux/module.h>
  17 #include <linux/kernel.h>
  18 #include <linux/errno.h>
  19 #include <linux/string.h>
  20 #include <linux/mm.h>
  21 #include <linux/slab.h>
  22 #include <linux/delay.h>
  23 #include <linux/device.h>
  24 #include <linux/kthread.h>
  25 #include <linux/fb.h>
  26 #include <linux/init.h>
  27 #include <asm/div64.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/rk_fb.h>
  30 #include <linux/linux_logo.h>
  31 #include <linux/dma-mapping.h>
  32 #include <linux/regulator/consumer.h>
  33
  34 #if defined(CONFIG_RK_HDMI)
  35 #include "hdmi/rk_hdmi.h"
  36 #endif
  37
  38 #if defined(CONFIG_ROCKCHIP_RGA) || defined(CONFIG_ROCKCHIP_RGA2)
  39 #include "rga/rga.h"
  40 #endif
  41
  42 #ifdef CONFIG_OF
  43 #include <linux/of.h>
  44 #include <linux/of_platform.h>
  45 #include <linux/of_gpio.h>
  46 #include <video/of_display_timing.h>
  47 #include <video/display_timing.h>
  48 #include <dt-bindings/rkfb/rk_fb.h>
  49 #endif
  50
  51 #if defined(CONFIG_ION_ROCKCHIP)
  52 #include <linux/rockchip_ion.h>
  53 #include <linux/rockchip-iovmm.h>
  54 #include <linux/dma-buf.h>
  55 #include <linux/highmem.h>
  56 #endif
  57
  58 #define H_USE_FENCE 1
  59 static int hdmi_switch_complete;
  60 static struct platform_device *fb_pdev;
  61 struct list_head saved_list;
  62
  63 #if defined(CONFIG_FB_MIRRORING)
  64 int (*video_data_to_mirroring) (struct fb_info *info, u32 yuv_phy[2]);
  65 EXPORT_SYMBOL(video_data_to_mirroring);
  66 #endif
  67
  68 struct rk_fb_reg_win_data g_reg_win_data[4];
  69 static int g_last_win_num;
  70 static int g_first_buf = 1;
  71 static struct rk_fb_trsm_ops *trsm_lvds_ops;
  72 static struct rk_fb_trsm_ops *trsm_edp_ops;
  73 static struct rk_fb_trsm_ops *trsm_mipi_ops;
  74 static int uboot_logo_on;
  75 int support_uboot_display(void)
  76 {
  77         return uboot_logo_on;
  78 }
  79
  80 int rk_fb_get_display_policy(void)
  81 {
  82         struct rk_fb *rk_fb;
  83
  84         if (fb_pdev) {
  85                 rk_fb = platform_get_drvdata(fb_pdev);
  86                 return rk_fb->disp_policy;
  87         } else {
  88                 return DISPLAY_POLICY_SDK;
  89         }
  90 }
  91
  92 int rk_fb_trsm_ops_register(struct rk_fb_trsm_ops *ops, int type)
  93 {
  94         switch (type) {
  95         case SCREEN_RGB:
  96         case SCREEN_LVDS:
  97         case SCREEN_DUAL_LVDS:
  98                 trsm_lvds_ops = ops;
  99                 break;
 100         case SCREEN_EDP:
 101                 trsm_edp_ops = ops;
 102                 break;
 103         case SCREEN_MIPI:
 104         case SCREEN_DUAL_MIPI:
 105                 trsm_mipi_ops = ops;
 106                 break;
 107         default:
 108                 printk(KERN_WARNING "%s:un supported transmitter:%d!\n",
 109                        __func__, type);
 110                 break;
 111         }
 112         return 0;
 113 }
 114
 115 struct rk_fb_trsm_ops *rk_fb_trsm_ops_get(int type)
 116 {
 117         struct rk_fb_trsm_ops *ops;
 118         switch (type) {
 119         case SCREEN_RGB:
 120         case SCREEN_LVDS:
 121         case SCREEN_DUAL_LVDS:
 122                 ops = trsm_lvds_ops;
 123                 break;
 124         case SCREEN_EDP:
 125                 ops = trsm_edp_ops;
 126                 break;
 127         case SCREEN_MIPI:
 128         case SCREEN_DUAL_MIPI:
 129                 ops = trsm_mipi_ops;
 130                 break;
 131         default:
 132                 ops = NULL;
 133                 printk(KERN_WARNING "%s:un supported transmitter:%d!\n",
 134                        __func__, type);
 135                 break;
 136         }
 137         return ops;
 138 }
 139
 140 int rk_fb_pixel_width(int data_format)
 141 {
 142         int pixel_width;
 143         switch (data_format) {
 144         case XBGR888:
 145         case ABGR888:
 146         case ARGB888:
 147                 pixel_width = 4 * 8;
 148                 break;
 149         case RGB888:
 150                 pixel_width = 3 * 8;
 151                 break;
 152         case RGB565:
 153                 pixel_width = 2 * 8;
 154                 break;
 155         case YUV422:
 156         case YUV420:
 157         case YUV444:
 158                 pixel_width = 1 * 8;
 159                 break;
 160         case YUV422_A:
 161         case YUV420_A:
 162         case YUV444_A:
 163                 pixel_width = 8;
 164                 break;
 165         default:
 166                 printk(KERN_WARNING "%s:un supported format:0x%x\n",
 167                        __func__, data_format);
 168                 return -EINVAL;
 169         }
 170         return pixel_width;
 171 }
 172
 173 static int rk_fb_data_fmt(int data_format, int bits_per_pixel)
 174 {
 175         int fb_data_fmt;
 176         if (data_format) {
 177                 switch (data_format) {
 178                 case HAL_PIXEL_FORMAT_RGBX_8888:
 179                         fb_data_fmt = XBGR888;
 180                         break;
 181                 case HAL_PIXEL_FORMAT_RGBA_8888:
 182                         fb_data_fmt = ABGR888;
 183                         break;
 184                 case HAL_PIXEL_FORMAT_BGRA_8888:
 185                         fb_data_fmt = ARGB888;
 186                         break;
 187                 case HAL_PIXEL_FORMAT_RGB_888:
 188                         fb_data_fmt = RGB888;
 189                         break;
 190                 case HAL_PIXEL_FORMAT_RGB_565:
 191                         fb_data_fmt = RGB565;
 192                         break;
 193                 case HAL_PIXEL_FORMAT_YCbCr_422_SP:     /* yuv422 */
 194                         fb_data_fmt = YUV422;
 195                         break;
 196                 case HAL_PIXEL_FORMAT_YCrCb_NV12:       /* YUV420---uvuvuv */
 197                         fb_data_fmt = YUV420;
 198                         break;
 199                 case HAL_PIXEL_FORMAT_YCrCb_444:        /* yuv444 */
 200                         fb_data_fmt = YUV444;
 201                         break;
 202                 case HAL_PIXEL_FORMAT_YCrCb_NV12_10:    /* yuv444 */
 203                         fb_data_fmt = YUV420_A;
 204                         break;
 205                 case HAL_PIXEL_FORMAT_YCbCr_422_SP_10:  /* yuv444 */
 206                         fb_data_fmt = YUV422_A;
 207                         break;
 208                 case HAL_PIXEL_FORMAT_YCrCb_420_SP_10:  /* yuv444 */
 209                         fb_data_fmt = YUV444_A;
 210                         break;
 211                 default:
 212                         printk(KERN_WARNING "%s:un supported format:0x%x\n",
 213                                __func__, data_format);
 214                         return -EINVAL;
 215                 }
 216         } else {
 217                 switch (bits_per_pixel) {
 218                 case 32:
 219                         fb_data_fmt = ARGB888;
 220                         break;
 221                 case 16:
 222                         fb_data_fmt = RGB565;
 223                         break;
 224                 default:
 225                         printk(KERN_WARNING
 226                                "%s:un supported bits_per_pixel:%d\n", __func__,
 227                                bits_per_pixel);
 228                         break;
 229                 }
 230         }
 231         return fb_data_fmt;
 232 }
 233
 234 /*
 235  * rk display power control parse from dts
 236  */
 237 int rk_disp_pwr_ctr_parse_dt(struct rk_lcdc_driver *dev_drv)
 238 {
 239         struct device_node *root = of_get_child_by_name(dev_drv->dev->of_node,
 240                                                         "power_ctr");
 241         struct device_node *child;
 242         struct rk_disp_pwr_ctr_list *pwr_ctr;
 243         struct list_head *pos;
 244         enum of_gpio_flags flags;
 245         u32 val = 0;
 246         u32 debug = 0;
 247         int ret;
 248
 249         INIT_LIST_HEAD(&dev_drv->pwrlist_head);
 250         if (!root) {
 251                 dev_err(dev_drv->dev, "can't find power_ctr node for lcdc%d\n",
 252                         dev_drv->id);
 253                 return -ENODEV;
 254         }
 255
 256         for_each_child_of_node(root, child) {
 257                 pwr_ctr = kmalloc(sizeof(struct rk_disp_pwr_ctr_list),
 258                                   GFP_KERNEL);
 259                 strcpy(pwr_ctr->pwr_ctr.name, child->name);
 260                 if (!of_property_read_u32(child, "rockchip,power_type", &val)) {
 261                         if (val == GPIO) {
 262                                 pwr_ctr->pwr_ctr.type = GPIO;
 263                                 pwr_ctr->pwr_ctr.gpio = of_get_gpio_flags(child, 0, &flags);
 264                                 if (!gpio_is_valid(pwr_ctr->pwr_ctr.gpio)) {
 265                                         dev_err(dev_drv->dev, "%s ivalid gpio\n",
 266                                                 child->name);
 267                                         return -EINVAL;
 268                                 }
 269                                 pwr_ctr->pwr_ctr.atv_val = !(flags & OF_GPIO_ACTIVE_LOW);
 270                                 ret = gpio_request(pwr_ctr->pwr_ctr.gpio,
 271                                                    child->name);
 272                                 if (ret) {
 273                                         dev_err(dev_drv->dev,
 274                                                 "request %s gpio fail:%d\n",
 275                                                 child->name, ret);
 276                                 }
 277
 278                         } else {
 279                                 pwr_ctr->pwr_ctr.type = REGULATOR;
 280                                 pwr_ctr->pwr_ctr.rgl_name = NULL;
 281                                 ret = of_property_read_string(child, "rockchip,regulator_name",
 282                                                              &(pwr_ctr->pwr_ctr.rgl_name));
 283                                 if (ret || IS_ERR_OR_NULL(pwr_ctr->pwr_ctr.rgl_name))
 284                                         dev_err(dev_drv->dev, "get regulator name failed!\n");
 285                                 if (!of_property_read_u32(child, "rockchip,regulator_voltage", &val))
 286                                         pwr_ctr->pwr_ctr.volt = val;
 287                                 else
 288                                         pwr_ctr->pwr_ctr.volt = 0;
 289                         }
 290                 };
 291
 292                 if (!of_property_read_u32(child, "rockchip,delay", &val))
 293                         pwr_ctr->pwr_ctr.delay = val;
 294                 else
 295                         pwr_ctr->pwr_ctr.delay = 0;
 296                 list_add_tail(&pwr_ctr->list, &dev_drv->pwrlist_head);
 297         }
 298
 299         of_property_read_u32(root, "rockchip,debug", &debug);
 300
 301         if (debug) {
 302                 list_for_each(pos, &dev_drv->pwrlist_head) {
 303                         pwr_ctr = list_entry(pos, struct rk_disp_pwr_ctr_list,
 304                                              list);
 305                         printk(KERN_INFO "pwr_ctr_name:%s\n"
 306                                "pwr_type:%s\n"
 307                                "gpio:%d\n"
 308                                "atv_val:%d\n"
 309                                "delay:%d\n\n",
 310                                pwr_ctr->pwr_ctr.name,
 311                                (pwr_ctr->pwr_ctr.type == GPIO) ? "gpio" : "regulator",
 312                                pwr_ctr->pwr_ctr.gpio,
 313                                pwr_ctr->pwr_ctr.atv_val,
 314                                pwr_ctr->pwr_ctr.delay);
 315                 }
 316         }
 317
 318         return 0;
 319
 320 }
 321
 322 int rk_disp_pwr_enable(struct rk_lcdc_driver *dev_drv)
 323 {
 324         struct list_head *pos;
 325         struct rk_disp_pwr_ctr_list *pwr_ctr_list;
 326         struct pwr_ctr *pwr_ctr;
 327         struct regulator *regulator_lcd = NULL;
 328         int count = 10;
 329
 330         if (list_empty(&dev_drv->pwrlist_head))
 331                 return 0;
 332         list_for_each(pos, &dev_drv->pwrlist_head) {
 333                 pwr_ctr_list = list_entry(pos, struct rk_disp_pwr_ctr_list,
 334                                           list);
 335                 pwr_ctr = &pwr_ctr_list->pwr_ctr;
 336                 if (pwr_ctr->type == GPIO) {
 337                         gpio_direction_output(pwr_ctr->gpio, pwr_ctr->atv_val);
 338                         mdelay(pwr_ctr->delay);
 339                 } else if (pwr_ctr->type == REGULATOR) {
 340                         if (pwr_ctr->rgl_name)
 341                                 regulator_lcd = regulator_get(NULL, pwr_ctr->rgl_name);
 342                         if (regulator_lcd == NULL) {
 343                                 dev_err(dev_drv->dev,
 344                                         "%s: regulator get failed,regulator name:%s\n",
 345                                         __func__, pwr_ctr->rgl_name);
 346                                 continue;
 347                         }
 348                         regulator_set_voltage(regulator_lcd, pwr_ctr->volt, pwr_ctr->volt);
 349                         while (!regulator_is_enabled(regulator_lcd)) {
 350                                 if (regulator_enable(regulator_lcd) == 0 || count == 0)
 351                                         break;
 352                                 else
 353                                         dev_err(dev_drv->dev,
 354                                                 "regulator_enable failed,count=%d\n",
 355                                                 count);
 356                                 count--;
 357                         }
 358                         regulator_put(regulator_lcd);
 359                         msleep(pwr_ctr->delay);
 360                 }
 361         }
 362
 363         return 0;
 364 }
 365
 366 int rk_disp_pwr_disable(struct rk_lcdc_driver *dev_drv)
 367 {
 368         struct list_head *pos;
 369         struct rk_disp_pwr_ctr_list *pwr_ctr_list;
 370         struct pwr_ctr *pwr_ctr;
 371         struct regulator *regulator_lcd = NULL;
 372         int count = 10;
 373
 374         if (list_empty(&dev_drv->pwrlist_head))
 375                 return 0;
 376         list_for_each(pos, &dev_drv->pwrlist_head) {
 377                 pwr_ctr_list = list_entry(pos, struct rk_disp_pwr_ctr_list,
 378                                           list);
 379                 pwr_ctr = &pwr_ctr_list->pwr_ctr;
 380                 if (pwr_ctr->type == GPIO) {
 381                         gpio_set_value(pwr_ctr->gpio, !pwr_ctr->atv_val);
 382                 } else if (pwr_ctr->type == REGULATOR) {
 383                         if (pwr_ctr->rgl_name)
 384                                 regulator_lcd = regulator_get(NULL, pwr_ctr->rgl_name);
 385                         if (regulator_lcd == NULL) {
 386                                 dev_err(dev_drv->dev,
 387                                         "%s: regulator get failed,regulator name:%s\n",
 388                                         __func__, pwr_ctr->rgl_name);
 389                                 continue;
 390                         }
 391                         while (regulator_is_enabled(regulator_lcd) > 0) {
 392                                 if (regulator_disable(regulator_lcd) == 0 || count == 0)
 393                                         break;
 394                                 else
 395                                         dev_err(dev_drv->dev,
 396                                                 "regulator_disable failed,count=%d\n",
 397                                                 count);
 398                                 count--;
 399                         }
 400                         regulator_put(regulator_lcd);
 401                 }
 402         }
 403         return 0;
 404 }
 405
 406 int rk_fb_video_mode_from_timing(const struct display_timing *dt,
 407                                  struct rk_screen *screen)
 408 {
 409         screen->mode.pixclock = dt->pixelclock.typ;
 410         screen->mode.left_margin = dt->hback_porch.typ;
 411         screen->mode.right_margin = dt->hfront_porch.typ;
 412         screen->mode.xres = dt->hactive.typ;
 413         screen->mode.hsync_len = dt->hsync_len.typ;
 414         screen->mode.upper_margin = dt->vback_porch.typ;
 415         screen->mode.lower_margin = dt->vfront_porch.typ;
 416         screen->mode.yres = dt->vactive.typ;
 417         screen->mode.vsync_len = dt->vsync_len.typ;
 418         screen->type = dt->screen_type;
 419         screen->lvds_format = dt->lvds_format;
 420         screen->face = dt->face;
 421         screen->color_mode = dt->color_mode;
 422         screen->dsp_lut = dt->dsp_lut;
 423
 424         if (dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE)
 425                 screen->pin_dclk = 1;
 426         else
 427                 screen->pin_dclk = 0;
 428         if (dt->flags & DISPLAY_FLAGS_HSYNC_HIGH)
 429                 screen->pin_hsync = 1;
 430         else
 431                 screen->pin_hsync = 0;
 432         if (dt->flags & DISPLAY_FLAGS_VSYNC_HIGH)
 433                 screen->pin_vsync = 1;
 434         else
 435                 screen->pin_vsync = 0;
 436         if (dt->flags & DISPLAY_FLAGS_DE_HIGH)
 437                 screen->pin_den = 1;
 438         else
 439                 screen->pin_den = 0;
 440
 441         return 0;
 442
 443 }
 444
 445 int rk_fb_prase_timing_dt(struct device_node *np, struct rk_screen *screen)
 446 {
 447         struct display_timings *disp_timing;
 448         struct display_timing *dt;
 449         disp_timing = of_get_display_timings(np);
 450         if (!disp_timing) {
 451                 pr_err("parse display timing err\n");
 452                 return -EINVAL;
 453         }
 454         dt = display_timings_get(disp_timing, disp_timing->native_mode);
 455         rk_fb_video_mode_from_timing(dt, screen);
 456         return 0;
 457
 458 }
 459
 460 int rk_fb_calc_fps(struct rk_screen *screen, u32 pixclock)
 461 {
 462         int x, y;
 463         unsigned long long hz;
 464         if (!screen) {
 465                 printk(KERN_ERR "%s:null screen!\n", __func__);
 466                 return 0;
 467         }
 468         x = screen->mode.xres + screen->mode.left_margin +
 469             screen->mode.right_margin + screen->mode.hsync_len;
 470         y = screen->mode.yres + screen->mode.upper_margin +
 471             screen->mode.lower_margin + screen->mode.vsync_len;
 472
 473         hz = 1000000000000ULL;  /* 1e12 picoseconds per second */
 474
 475         hz += (x * y) / 2;
 476         do_div(hz, x * y);      /* divide by x * y with rounding */
 477
 478         hz += pixclock / 2;
 479         do_div(hz, pixclock);   /* divide by pixclock with rounding */
 480
 481         return hz;
 482 }
 483
 484 char *get_format_string(enum data_format format, char *fmt)
 485 {
 486         if (!fmt)
 487                 return NULL;
 488         switch (format) {
 489         case ARGB888:
 490                 strcpy(fmt, "ARGB888");
 491                 break;
 492         case RGB888:
 493                 strcpy(fmt, "RGB888");
 494                 break;
 495         case RGB565:
 496                 strcpy(fmt, "RGB565");
 497                 break;
 498         case YUV420:
 499                 strcpy(fmt, "YUV420");
 500                 break;
 501         case YUV422:
 502                 strcpy(fmt, "YUV422");
 503                 break;
 504         case YUV444:
 505                 strcpy(fmt, "YUV444");
 506                 break;
 507         case YUV420_A:
 508                 strcpy(fmt, "YUV420_A");
 509                 break;
 510         case YUV422_A:
 511                 strcpy(fmt, "YUV422_A");
 512                 break;
 513         case YUV444_A:
 514                 strcpy(fmt, "YUV444_A");
 515                 break;
 516         case XRGB888:
 517                 strcpy(fmt, "XRGB888");
 518                 break;
 519         case XBGR888:
 520                 strcpy(fmt, "XBGR888");
 521                 break;
 522         case ABGR888:
 523                 strcpy(fmt, "ABGR888");
 524                 break;
 525         default:
 526                 strcpy(fmt, "invalid");
 527                 break;
 528         }
 529
 530         return fmt;
 531
 532 }
 533
 534 /*
 535  * this is for hdmi
 536  * name: lcdc device name ,lcdc0 , lcdc1
 537  */
 538 struct rk_lcdc_driver *rk_get_lcdc_drv(char *name)
 539 {
 540         struct rk_fb *inf = NULL;
 541         struct rk_lcdc_driver *dev_drv = NULL;
 542         int i = 0;
 543
 544         if (likely(fb_pdev))
 545                 inf = platform_get_drvdata(fb_pdev);
 546         else
 547                 return NULL;
 548
 549         for (i = 0; i < inf->num_lcdc; i++) {
 550                 if (!strcmp(inf->lcdc_dev_drv[i]->name, name)) {
 551                         dev_drv = inf->lcdc_dev_drv[i];
 552                         break;
 553                 }
 554         }
 555
 556         return dev_drv;
 557 }
 558
 559 static struct rk_lcdc_driver *rk_get_prmry_lcdc_drv(void)
 560 {
 561         struct rk_fb *inf = NULL;
 562         struct rk_lcdc_driver *dev_drv = NULL;
 563         int i = 0;
 564
 565         if (likely(fb_pdev))
 566                 inf = platform_get_drvdata(fb_pdev);
 567         else
 568                 return NULL;
 569
 570         for (i = 0; i < inf->num_lcdc; i++) {
 571                 if (inf->lcdc_dev_drv[i]->prop == PRMRY) {
 572                         dev_drv = inf->lcdc_dev_drv[i];
 573                         break;
 574                 }
 575         }
 576
 577         return dev_drv;
 578 }
 579
 580 /*
 581  * get one frame time of the prmry screen, unit: us
 582  */
 583 u32 rk_fb_get_prmry_screen_ft(void)
 584 {
 585         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 586         uint32_t htotal, vtotal, pixclock_ps;
 587         u64 pix_total, ft_us;
 588
 589         if (unlikely(!dev_drv))
 590                 return 0;
 591
 592         pixclock_ps = dev_drv->pixclock;
 593
 594         vtotal = (dev_drv->cur_screen->mode.upper_margin +
 595                  dev_drv->cur_screen->mode.lower_margin +
 596                  dev_drv->cur_screen->mode.yres +
 597                  dev_drv->cur_screen->mode.vsync_len);
 598         htotal = (dev_drv->cur_screen->mode.left_margin +
 599                  dev_drv->cur_screen->mode.right_margin +
 600                  dev_drv->cur_screen->mode.xres +
 601                  dev_drv->cur_screen->mode.hsync_len);
 602         pix_total = htotal * vtotal;
 603         ft_us = pix_total * pixclock_ps;
 604         do_div(ft_us, 1000000);
 605         if (dev_drv->frame_time.ft == 0)
 606                 dev_drv->frame_time.ft = ft_us;
 607
 608         ft_us = dev_drv->frame_time.framedone_t - dev_drv->frame_time.last_framedone_t;
 609         do_div(ft_us, 1000);
 610         ft_us = min(dev_drv->frame_time.ft, (u32)ft_us);
 611         if (ft_us != 0)
 612                 dev_drv->frame_time.ft = ft_us;
 613
 614         return dev_drv->frame_time.ft;
 615 }
 616
 617 /*
 618  * get the vblanking time of the prmry screen, unit: us
 619  */
 620 u32 rk_fb_get_prmry_screen_vbt(void)
 621 {
 622         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 623         uint32_t htotal, vblank, pixclock_ps;
 624         u64 pix_blank, vbt_us;
 625
 626         if (unlikely(!dev_drv))
 627                 return 0;
 628
 629         pixclock_ps = dev_drv->pixclock;
 630
 631         htotal = (dev_drv->cur_screen->mode.left_margin +
 632                  dev_drv->cur_screen->mode.right_margin +
 633                  dev_drv->cur_screen->mode.xres +
 634                  dev_drv->cur_screen->mode.hsync_len);
 635         vblank = (dev_drv->cur_screen->mode.upper_margin +
 636                  dev_drv->cur_screen->mode.lower_margin +
 637                  dev_drv->cur_screen->mode.vsync_len);
 638         pix_blank = htotal * vblank;
 639         vbt_us = pix_blank * pixclock_ps;
 640         do_div(vbt_us, 1000000);
 641         return (u32)vbt_us;
 642 }
 643
 644 /*
 645  * get the frame done time of the prmry screen, unit: us
 646  */
 647 u64 rk_fb_get_prmry_screen_framedone_t(void)
 648 {
 649         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 650
 651         if (unlikely(!dev_drv))
 652                 return 0;
 653         else
 654                 return dev_drv->frame_time.framedone_t;
 655 }
 656
 657 /*
 658  * set prmry screen status
 659  */
 660 int rk_fb_set_prmry_screen_status(int status)
 661 {
 662         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 663         struct rk_screen *screen;
 664
 665         if (unlikely(!dev_drv))
 666                 return 0;
 667
 668         screen = dev_drv->cur_screen;
 669         switch (status) {
 670         case SCREEN_PREPARE_DDR_CHANGE:
 671                 if (screen->type == SCREEN_MIPI
 672                         || screen->type == SCREEN_DUAL_MIPI) {
 673                         if (dev_drv->trsm_ops->dsp_pwr_off)
 674                                 dev_drv->trsm_ops->dsp_pwr_off();
 675                 }
 676                 break;
 677         case SCREEN_UNPREPARE_DDR_CHANGE:
 678                 if (screen->type == SCREEN_MIPI
 679                         || screen->type == SCREEN_DUAL_MIPI) {
 680                         if (dev_drv->trsm_ops->dsp_pwr_on)
 681                                 dev_drv->trsm_ops->dsp_pwr_on();
 682                 }
 683                 break;
 684         default:
 685                 break;
 686         }
 687
 688         return 0;
 689 }
 690
 691 static struct rk_lcdc_driver *rk_get_extend_lcdc_drv(void)
 692 {
 693         struct rk_fb *inf = NULL;
 694         struct rk_lcdc_driver *dev_drv = NULL;
 695         int i = 0;
 696
 697         if (likely(fb_pdev))
 698                 inf = platform_get_drvdata(fb_pdev);
 699         else
 700                 return NULL;
 701
 702         for (i = 0; i < inf->num_lcdc; i++) {
 703                 if (inf->lcdc_dev_drv[i]->prop == EXTEND) {
 704                         dev_drv = inf->lcdc_dev_drv[i];
 705                         break;
 706                 }
 707         }
 708
 709         return dev_drv;
 710 }
 711
 712 u32 rk_fb_get_prmry_screen_pixclock(void)
 713 {
 714         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 715
 716         if (unlikely(!dev_drv))
 717                 return 0;
 718         else
 719                 return dev_drv->pixclock;
 720 }
 721
 722 int rk_fb_poll_prmry_screen_vblank(void)
 723 {
 724         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 725
 726         if (likely(dev_drv)) {
 727                 if (dev_drv->ops->poll_vblank)
 728                         return dev_drv->ops->poll_vblank(dev_drv);
 729                 else
 730                         return RK_LF_STATUS_NC;
 731         } else {
 732                 return RK_LF_STATUS_NC;
 733         }
 734 }
 735
 736 bool rk_fb_poll_wait_frame_complete(void)
 737 {
 738         uint32_t timeout = RK_LF_MAX_TIMEOUT;
 739         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
 740
 741         if (likely(dev_drv)) {
 742                 if (dev_drv->ops->set_irq_to_cpu)
 743                         dev_drv->ops->set_irq_to_cpu(dev_drv, 0);
 744         }
 745
 746         if (rk_fb_poll_prmry_screen_vblank() == RK_LF_STATUS_NC) {
 747                 if (likely(dev_drv)) {
 748                         if (dev_drv->ops->set_irq_to_cpu)
 749                                 dev_drv->ops->set_irq_to_cpu(dev_drv, 1);
 750                 }
 751                 return false;
 752         }
 753         while (!(rk_fb_poll_prmry_screen_vblank() == RK_LF_STATUS_FR) && --timeout)
 754                 ;
 755         while (!(rk_fb_poll_prmry_screen_vblank() == RK_LF_STATUS_FC) && --timeout)
 756                 ;
 757         if (likely(dev_drv)) {
 758                 if (dev_drv->ops->set_irq_to_cpu)
 759                         dev_drv->ops->set_irq_to_cpu(dev_drv, 1);
 760         }
 761
 762         return true;
 763 }
 764
 765
 766 /* rk_fb_get_sysmmu_device_by_compatible()
 767  * @compt: dts device compatible name
 768  * return value: success: pointer to the device inside of platform device
 769  *               fail: NULL
 770  */
 771 struct device *rk_fb_get_sysmmu_device_by_compatible(const char *compt)
 772 {
 773         struct device_node *dn = NULL;
 774         struct platform_device *pd = NULL;
 775         struct device *ret = NULL ;
 776
 777         dn = of_find_compatible_node(NULL, NULL, compt);
 778         if (!dn) {
 779                 printk("can't find device node %s \r\n", compt);
 780                 return NULL;
 781         }
 782
 783         pd = of_find_device_by_node(dn);
 784         if (!pd) {
 785                 printk("can't find platform device in device node %s \r\n", compt);
 786                 return  NULL;
 787         }
 788         ret = &pd->dev;
 789
 790         return ret;
 791 }
 792
 793 #ifdef CONFIG_IOMMU_API
 794 void rk_fb_platform_set_sysmmu(struct device *sysmmu, struct device *dev)
 795 {
 796         dev->archdata.iommu = sysmmu;
 797 }
 798 #else
 799 void rk_fb_platform_set_sysmmu(struct device *sysmmu, struct device *dev)
 800 {
 801
 802 }
 803 #endif
 804
 805 static int rk_fb_open(struct fb_info *info, int user)
 806 {
 807         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
 808         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 809         int win_id;
 810
 811         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
 812         fb_par->state++;
 813         /* if this win aready opened ,no need to reopen */
 814         if (dev_drv->win[win_id]->state)
 815                 return 0;
 816         else
 817                 dev_drv->ops->open(dev_drv, win_id, 1);
 818         return 0;
 819 }
 820
 821 static int get_extend_fb_id(struct fb_info *info)
 822 {
 823         int fb_id = 0;
 824         char *id = info->fix.id;
 825         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
 826         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 827
 828         if (!strcmp(id, "fb0"))
 829                 fb_id = 0;
 830         else if (!strcmp(id, "fb1"))
 831                 fb_id = 1;
 832         else if (!strcmp(id, "fb2") && (dev_drv->lcdc_win_num > 2))
 833                 fb_id = 2;
 834         else if (!strcmp(id, "fb3") && (dev_drv->lcdc_win_num > 3))
 835                 fb_id = 3;
 836         return fb_id;
 837 }
 838
 839 static int rk_fb_close(struct fb_info *info, int user)
 840 {
 841         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
 842         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 843         struct rk_lcdc_win *win = NULL;
 844         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
 845
 846         if (win_id >= 0) {
 847                 win = dev_drv->win[win_id];
 848                 fb_par->state--;
 849                 if (!fb_par->state) {
 850                         if (fb_par->fb_phy_base > 0)
 851                                 info->fix.smem_start = fb_par->fb_phy_base;
 852                         info->var.xres = dev_drv->screen0->mode.xres;
 853                         info->var.yres = dev_drv->screen0->mode.yres;
 854                         /*
 855                         info->var.grayscale |=
 856                             (info->var.xres << 8) + (info->var.yres << 20);
 857                         */
 858                         info->var.xres_virtual = info->var.xres;
 859                         info->var.yres_virtual = info->var.yres;
 860 #if defined(CONFIG_LOGO_LINUX_BMP)
 861                         info->var.bits_per_pixel = 32;
 862 #else
 863                         info->var.bits_per_pixel = 16;
 864 #endif
 865                         info->fix.line_length =
 866                             (info->var.xres_virtual) * (info->var.bits_per_pixel >> 3);
 867                         info->var.width = dev_drv->screen0->width;
 868                         info->var.height = dev_drv->screen0->height;
 869                         info->var.pixclock = dev_drv->pixclock;
 870                         info->var.left_margin = dev_drv->screen0->mode.left_margin;
 871                         info->var.right_margin = dev_drv->screen0->mode.right_margin;
 872                         info->var.upper_margin = dev_drv->screen0->mode.upper_margin;
 873                         info->var.lower_margin = dev_drv->screen0->mode.lower_margin;
 874                         info->var.vsync_len = dev_drv->screen0->mode.vsync_len;
 875                         info->var.hsync_len = dev_drv->screen0->mode.hsync_len;
 876                 }
 877         }
 878
 879         return 0;
 880 }
 881
 882
 883 #if defined(CONFIG_RK29_IPP)
 884 static int get_ipp_format(int fmt)
 885 {
 886         int ipp_fmt = IPP_XRGB_8888;
 887         switch (fmt) {
 888         case HAL_PIXEL_FORMAT_RGBX_8888:
 889         case HAL_PIXEL_FORMAT_RGBA_8888:
 890         case HAL_PIXEL_FORMAT_BGRA_8888:
 891         case HAL_PIXEL_FORMAT_RGB_888:
 892                 ipp_fmt = IPP_XRGB_8888;
 893                 break;
 894         case HAL_PIXEL_FORMAT_RGB_565:
 895                 ipp_fmt = IPP_RGB_565;
 896                 break;
 897         case HAL_PIXEL_FORMAT_YCbCr_422_SP:
 898                 ipp_fmt = IPP_Y_CBCR_H2V1;
 899                 break;
 900         case HAL_PIXEL_FORMAT_YCrCb_NV12:
 901                 ipp_fmt = IPP_Y_CBCR_H2V2;
 902                 break;
 903         case HAL_PIXEL_FORMAT_YCrCb_444:
 904                 ipp_fmt = IPP_Y_CBCR_H1V1;
 905                 break;
 906         default:
 907                 ipp_fmt = IPP_IMGTYPE_LIMIT;
 908                 break;
 909         }
 910
 911         return ipp_fmt;
 912 }
 913
 914 static void ipp_win_check(int *dst_w, int *dst_h, int *dst_vir_w,
 915                           int rotation, int fmt)
 916 {
 917         int align16 = 2;
 918         int align64 = 8;
 919
 920         if (fmt == IPP_XRGB_8888) {
 921                 align16 = 1;
 922                 align64 = 2;
 923         } else if (fmt == IPP_RGB_565) {
 924                 align16 = 1;
 925                 align64 = 4;
 926         } else {
 927                 align16 = 2;
 928                 align64 = 8;
 929         }
 930         align16 -= 1;           /*for YUV, 1 */
 931         align64 -= 1;           /*for YUV, 7 */
 932
 933         if (rotation == IPP_ROT_0) {
 934                 if (fmt > IPP_RGB_565) {
 935                         if ((*dst_w & 1) != 0)
 936                                 *dst_w = *dst_w + 1;
 937                         if ((*dst_h & 1) != 0)
 938                                 *dst_h = *dst_h + 1;
 939                         if (*dst_vir_w < *dst_w)
 940                                 *dst_vir_w = *dst_w;
 941                 }
 942         } else {
 943                 if ((*dst_w & align64) != 0)
 944                         *dst_w = (*dst_w + align64) & (~align64);
 945                 if ((fmt > IPP_RGB_565) && ((*dst_h & 1) == 1))
 946                         *dst_h = *dst_h + 1;
 947                 if (*dst_vir_w < *dst_w)
 948                         *dst_vir_w = *dst_w;
 949         }
 950 }
 951
 952 static void fb_copy_by_ipp(struct fb_info *dst_info,
 953                                 struct fb_info *src_info)
 954 {
 955         struct rk29_ipp_req ipp_req;
 956         uint32_t rotation = 0;
 957         int dst_w, dst_h, dst_vir_w;
 958         int ipp_fmt;
 959         u8 data_format = (dst_info->var.nonstd) & 0xff;
 960         struct rk_fb_par *fb_par = (struct rk_fb_par *)dst_info->par;
 961         struct rk_lcdc_driver *ext_dev_drv = fb_par->lcdc_drv;
 962         u16 orientation = ext_dev_drv->rotate_mode;
 963
 964         memset(&ipp_req, 0, sizeof(struct rk29_ipp_req));
 965
 966         switch (orientation) {
 967         case 0:
 968                 rotation = IPP_ROT_0;
 969                 break;
 970         case ROTATE_90:
 971                 rotation = IPP_ROT_90;
 972                 break;
 973         case ROTATE_180:
 974                 rotation = IPP_ROT_180;
 975                 break;
 976         case ROTATE_270:
 977                 rotation = IPP_ROT_270;
 978                 break;
 979         default:
 980                 rotation = IPP_ROT_270;
 981                 break;
 982         }
 983
 984         dst_w = dst_info->var.xres;
 985         dst_h = dst_info->var.yres;
 986         dst_vir_w = dst_info->var.xres_virtual;
 987         ipp_fmt = get_ipp_format(data_format);
 988         ipp_win_check(&dst_w, &dst_h, &dst_vir_w, rotation, ipp_fmt);
 989         ipp_req.src0.YrgbMst = src_info->fix.smem_start + offset;
 990         ipp_req.src0.w = src_info->var.xres;
 991         ipp_req.src0.h = src_info->var.yres;
 992         ipp_req.src_vir_w = src_info->var.xres_virtual;
 993         ipp_req.src0.fmt = ipp_fmt;
 994
 995         ipp_req.dst0.YrgbMst = dst_info->fix.smem_start + offset;
 996         ipp_req.dst0.w = dst_w;
 997         ipp_req.dst0.h = dst_h;
 998         ipp_req.dst_vir_w = dst_vir_w;
 999         ipp_req.dst0.fmt = ipp_fmt;
1000
1001         ipp_req.timeout = 100;
1002         ipp_req.flag = rotation;
1003         ipp_blit_sync(&ipp_req);
1004 }
1005
1006 #endif
1007
1008 #if defined(CONFIG_ROCKCHIP_RGA) || defined(CONFIG_ROCKCHIP_RGA2)
1009 static int get_rga_format(int fmt)
1010 {
1011         int rga_fmt = 0;
1012
1013         switch (fmt) {
1014         case XBGR888:
1015                 rga_fmt = RK_FORMAT_RGBX_8888;
1016                 break;
1017         case ABGR888:
1018                 rga_fmt = RK_FORMAT_RGBA_8888;
1019                 break;
1020         case ARGB888:
1021                 rga_fmt = RK_FORMAT_BGRA_8888;
1022                 break;
1023         case RGB888:
1024                 rga_fmt = RK_FORMAT_RGB_888;
1025                 break;
1026         case RGB565:
1027                 rga_fmt = RK_FORMAT_RGB_565;
1028                 break;
1029         case YUV422:
1030                 rga_fmt = RK_FORMAT_YCbCr_422_SP;
1031                 break;
1032         case YUV420:
1033                 rga_fmt = RK_FORMAT_YCbCr_420_SP;
1034                 break;
1035         default:
1036                 rga_fmt = RK_FORMAT_RGBA_8888;
1037                 break;
1038         }
1039
1040         return rga_fmt;
1041 }
1042
1043 static void rga_win_check(struct rk_lcdc_win *dst_win,
1044                           struct rk_lcdc_win *src_win)
1045 {
1046         int format = 0;
1047
1048         format = get_rga_format(src_win->format);
1049         /* width and height must be even number */
1050         if (format >= RK_FORMAT_YCbCr_422_SP &&
1051             format <= RK_FORMAT_YCrCb_420_P) {
1052                 if ((src_win->area[0].xact % 2) != 0)
1053                         src_win->area[0].xact += 1;
1054                 if ((src_win->area[0].yact % 2) != 0)
1055                         src_win->area[0].yact += 1;
1056         }
1057         if (src_win->area[0].xvir < src_win->area[0].xact)
1058                 src_win->area[0].xvir = src_win->area[0].xact;
1059         if (src_win->area[0].yvir < src_win->area[0].yact)
1060                 src_win->area[0].yvir = src_win->area[0].yact;
1061
1062         format = get_rga_format(dst_win->format);
1063         if (format >= RK_FORMAT_YCbCr_422_SP &&
1064             format <= RK_FORMAT_YCrCb_420_P) {
1065                 if ((dst_win->area[0].xact % 2) != 0)
1066                         dst_win->area[0].xact += 1;
1067                 if ((dst_win->area[0].yact % 2) != 0)
1068                         dst_win->area[0].yact += 1;
1069         }
1070         if (dst_win->area[0].xvir < dst_win->area[0].xact)
1071                 dst_win->area[0].xvir = dst_win->area[0].xact;
1072         if (dst_win->area[0].yvir < dst_win->area[0].yact)
1073                 dst_win->area[0].yvir = dst_win->area[0].yact;
1074 }
1075
1076 static void win_copy_by_rga(struct rk_lcdc_win *dst_win,
1077                             struct rk_lcdc_win *src_win,
1078                             u16 orientation, int iommu_en)
1079 {
1080         struct rga_req Rga_Request;
1081         long ret = 0;
1082         /* int fd = 0; */
1083
1084         memset(&Rga_Request, 0, sizeof(Rga_Request));
1085         rga_win_check(dst_win, src_win);
1086
1087         switch (orientation) {
1088         case ROTATE_90:
1089                 Rga_Request.rotate_mode = 1;
1090                 Rga_Request.sina = 65536;
1091                 Rga_Request.cosa = 0;
1092                 Rga_Request.dst.act_w = dst_win->area[0].yact;
1093                 Rga_Request.dst.act_h = dst_win->area[0].xact;
1094                 Rga_Request.dst.x_offset = dst_win->area[0].xact - 1;
1095                 Rga_Request.dst.y_offset = 0;
1096                 break;
1097         case ROTATE_180:
1098                 Rga_Request.rotate_mode = 1;
1099                 Rga_Request.sina = 0;
1100                 Rga_Request.cosa = -65536;
1101                 Rga_Request.dst.act_w = dst_win->area[0].xact;
1102                 Rga_Request.dst.act_h = dst_win->area[0].yact;
1103                 Rga_Request.dst.x_offset = dst_win->area[0].xact - 1;
1104                 Rga_Request.dst.y_offset = dst_win->area[0].yact - 1;
1105                 break;
1106         case ROTATE_270:
1107                 Rga_Request.rotate_mode = 1;
1108                 Rga_Request.sina = -65536;
1109                 Rga_Request.cosa = 0;
1110                 Rga_Request.dst.act_w = dst_win->area[0].yact;
1111                 Rga_Request.dst.act_h = dst_win->area[0].xact;
1112                 Rga_Request.dst.x_offset = 0;
1113                 Rga_Request.dst.y_offset = dst_win->area[0].yact - 1;
1114                 break;
1115         default:
1116                 Rga_Request.rotate_mode = 0;
1117                 Rga_Request.dst.act_w = dst_win->area[0].xact;
1118                 Rga_Request.dst.act_h = dst_win->area[0].yact;
1119                 Rga_Request.dst.x_offset = dst_win->area[0].xact - 1;
1120                 Rga_Request.dst.y_offset = dst_win->area[0].yact - 1;
1121                 break;
1122         }
1123
1124 /*
1125         fd = ion_share_dma_buf_fd(rk_fb->ion_client, src_win->area[0].ion_hdl);
1126         Rga_Request.src.yrgb_addr = fd;
1127         fd = ion_share_dma_buf_fd(rk_fb->ion_client, dst_win->area[0].ion_hdl);
1128         Rga_Request.dst.yrgb_addr = fd;
1129 */
1130         Rga_Request.src.yrgb_addr = 0;
1131         Rga_Request.src.uv_addr =
1132             src_win->area[0].smem_start + src_win->area[0].y_offset;
1133         Rga_Request.src.v_addr = 0;
1134
1135         Rga_Request.dst.yrgb_addr = 0;
1136         Rga_Request.dst.uv_addr =
1137             dst_win->area[0].smem_start + dst_win->area[0].y_offset;
1138         Rga_Request.dst.v_addr = 0;
1139
1140         Rga_Request.src.vir_w = src_win->area[0].xvir;
1141         Rga_Request.src.vir_h = src_win->area[0].yvir;
1142         Rga_Request.src.format = get_rga_format(src_win->format);
1143         Rga_Request.src.act_w = src_win->area[0].xact;
1144         Rga_Request.src.act_h = src_win->area[0].yact;
1145         Rga_Request.src.x_offset = 0;
1146         Rga_Request.src.y_offset = 0;
1147
1148         Rga_Request.dst.vir_w = dst_win->area[0].xvir;
1149         Rga_Request.dst.vir_h = dst_win->area[0].yvir;
1150         Rga_Request.dst.format = get_rga_format(dst_win->format);
1151
1152         Rga_Request.clip.xmin = 0;
1153         Rga_Request.clip.xmax = dst_win->area[0].xact - 1;
1154         Rga_Request.clip.ymin = 0;
1155         Rga_Request.clip.ymax = dst_win->area[0].yact - 1;
1156         Rga_Request.scale_mode = 0;
1157 #if defined(CONFIG_ROCKCHIP_IOMMU)
1158         if (iommu_en) {
1159                 Rga_Request.mmu_info.mmu_en = 1;
1160                 Rga_Request.mmu_info.mmu_flag = 1;
1161         } else {
1162                 Rga_Request.mmu_info.mmu_en = 0;
1163                 Rga_Request.mmu_info.mmu_flag = 0;
1164         }
1165 #else
1166         Rga_Request.mmu_info.mmu_en = 0;
1167         Rga_Request.mmu_info.mmu_flag = 0;
1168 #endif
1169
1170         ret = rga_ioctl_kernel(&Rga_Request);
1171 }
1172
1173 /*
1174  * This function is used for copying fb by RGA Module
1175  * RGA only support copy RGB to RGB
1176  * RGA2 support copy RGB to RGB and YUV to YUV
1177  */
1178 static void fb_copy_by_rga(struct fb_info *dst_info,
1179                                 struct fb_info *src_info)
1180 {
1181         struct rk_fb_par *src_fb_par = (struct rk_fb_par *)src_info->par;
1182         struct rk_fb_par *dst_fb_par = (struct rk_fb_par *)dst_info->par;
1183         struct rk_lcdc_driver *dev_drv = src_fb_par->lcdc_drv;
1184         struct rk_lcdc_driver *ext_dev_drv = dst_fb_par->lcdc_drv;
1185         int win_id = 0, ext_win_id;
1186         struct rk_lcdc_win *src_win, *dst_win;
1187
1188         win_id = dev_drv->ops->fb_get_win_id(dev_drv, src_info->fix.id);
1189         src_win = dev_drv->win[win_id];
1190
1191         ext_win_id =
1192             ext_dev_drv->ops->fb_get_win_id(ext_dev_drv, dst_info->fix.id);
1193         dst_win = ext_dev_drv->win[ext_win_id];
1194
1195         win_copy_by_rga(dst_win, src_win, ext_dev_drv->rotate_mode,
1196                         ext_dev_drv->iommu_enabled);
1197 }
1198
1199 #endif
1200
1201 static int rk_fb_rotate(struct fb_info *dst_info,
1202                           struct fb_info *src_info)
1203 {
1204
1205 #if defined(CONFIG_RK29_IPP)
1206         fb_copy_by_ipp(dst_info, src_info);
1207 #elif defined(CONFIG_ROCKCHIP_RGA) || defined(CONFIG_ROCKCHIP_RGA2)
1208         fb_copy_by_rga(dst_info, src_info);
1209 #else
1210         return -1;
1211 #endif
1212         return 0;
1213 }
1214
1215 static int rk_fb_win_rotate(struct rk_lcdc_win *dst_win,
1216                             struct rk_lcdc_win *src_win,
1217                             u16 rotate, int iommu_en)
1218 {
1219 #if defined(CONFIG_ROCKCHIP_RGA) || defined(CONFIG_ROCKCHIP_RGA2)
1220         win_copy_by_rga(dst_win, src_win, rotate, iommu_en);
1221 #else
1222         return -1;
1223 #endif
1224         return 0;
1225 }
1226
1227 static int rk_fb_set_ext_win_buffer(struct rk_lcdc_win *ext_win,
1228                                          struct rk_lcdc_win *win,
1229                                          u16 rotate, int iommu_en)
1230 {
1231         struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
1232         struct fb_info *ext_info = rk_fb->fb[(rk_fb->num_fb >> 1)];
1233         struct rk_fb_par *ext_fb_par = (struct rk_fb_par *)ext_info->par;
1234         struct rk_lcdc_driver *ext_dev_drv = rk_get_extend_lcdc_drv();
1235         struct rk_lcdc_win *last_win;
1236         static u8 fb_index = 0;
1237         ion_phys_addr_t phy_addr;
1238         size_t len = 0;
1239         int ret = 0;
1240         bool is_yuv = false;
1241
1242         if (unlikely(!ext_win) || unlikely(!win))
1243                 return -1;
1244
1245         if (rk_fb->disp_mode != DUAL || ext_info == NULL)
1246                 return 0;
1247
1248         switch (ext_win->format) {
1249         case YUV422:
1250         case YUV420:
1251         case YUV444:
1252         case YUV422_A:
1253         case YUV420_A:
1254         case YUV444_A:
1255                 is_yuv = true;
1256                 break;
1257         default:
1258                 is_yuv = false;
1259                 break;
1260         }
1261
1262         /* no rotate mode */
1263         if (rotate <= X_Y_MIRROR) {
1264                 if (iommu_en) {
1265                         ret = ion_map_iommu(ext_dev_drv->dev,
1266                                             rk_fb->ion_client,
1267                                             win->area[0].ion_hdl,
1268                                             (unsigned long *)&phy_addr,
1269                                             (unsigned long *)&len);
1270                         if (ret < 0) {
1271                                 dev_err(ext_dev_drv->dev, "ion map to get phy addr failed\n");
1272                                 ion_free(rk_fb->ion_client, win->area[0].ion_hdl);
1273                                 return -ENOMEM;
1274                         }
1275                         ext_win->area[0].smem_start = phy_addr;
1276                         ext_win->area[0].y_offset = win->area[0].y_offset;
1277                         if (is_yuv) {
1278                                 ext_win->area[0].cbr_start = win->area[0].cbr_start;
1279                                 ext_win->area[0].c_offset = win->area[0].c_offset;
1280                         } else {
1281                                 ext_win->area[0].cbr_start = 0;
1282                                 ext_win->area[0].c_offset = 0;
1283                         }
1284                 } else {
1285                         ext_win->area[0].smem_start = win->area[0].smem_start;
1286                         ext_win->area[0].y_offset = win->area[0].y_offset;
1287                         if (is_yuv) {
1288                                 ext_win->area[0].cbr_start = win->area[0].cbr_start;
1289                                 ext_win->area[0].c_offset = win->area[0].c_offset;
1290                         } else {
1291                                 ext_win->area[0].cbr_start = 0;
1292                                 ext_win->area[0].c_offset = 0;
1293                         }
1294                 }
1295
1296                 return 0;
1297         }
1298
1299         /* rotate mode */
1300         if (!iommu_en) {
1301                 if (ext_win->id == 0) {
1302                         ext_win->area[0].smem_start = ext_fb_par->fb_phy_base;
1303                         ext_win->area[0].y_offset = (get_rotate_fb_size() >> 1) * fb_index;
1304                         if ((++fb_index) > 1)
1305                                 fb_index = 0;
1306                 } else {
1307                         ext_win->area[0].y_offset = 0;
1308                         last_win = ext_dev_drv->win[ext_win->id - 1];
1309                         if (last_win->area[0].cbr_start)
1310                                 ext_win->area[0].smem_start =
1311                                         last_win->area[0].cbr_start +
1312                                         last_win->area[0].c_offset +
1313                                         last_win->area[0].xvir * last_win->area[0].yvir;
1314                         else
1315                                 ext_win->area[0].smem_start =
1316                                         last_win->area[0].smem_start +
1317                                         last_win->area[0].y_offset +
1318                                         last_win->area[0].xvir * last_win->area[0].yvir;
1319                 }
1320
1321                 if (is_yuv) {
1322                         ext_win->area[0].cbr_start =
1323                                 ext_win->area[0].smem_start +
1324                                 ext_win->area[0].y_offset +
1325                                 ext_win->area[0].xvir * ext_win->area[0].yvir;
1326                         ext_win->area[0].c_offset = win->area[0].c_offset;
1327                 } else {
1328                         ext_win->area[0].cbr_start = 0;
1329                         ext_win->area[0].c_offset = 0;
1330                 }
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int rk_fb_pan_display(struct fb_var_screeninfo *var,
1337                              struct fb_info *info)
1338 {
1339         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
1340         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
1341         struct rk_fb_par *extend_fb_par = NULL;
1342         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
1343         struct fb_fix_screeninfo *fix = &info->fix;
1344         struct fb_info *extend_info = NULL;
1345         struct rk_lcdc_driver *extend_dev_drv = NULL;
1346         int win_id = 0, extend_win_id = 0;
1347         struct rk_lcdc_win *extend_win = NULL;
1348         struct rk_lcdc_win *win = NULL;
1349         struct rk_screen *screen = dev_drv->cur_screen;
1350         int fb_id = 0;
1351
1352         u32 xoffset = var->xoffset;
1353         u32 yoffset = var->yoffset;
1354         u32 xvir = var->xres_virtual;
1355         /* u32 yvir = var->yres_virtual; */
1356         /* u8 data_format = var->nonstd&0xff; */
1357
1358         u8 pixel_width;
1359         u32 vir_width_bit;
1360         u32 stride, uv_stride;
1361         u32 stride_32bit_1;
1362         u32 stride_32bit_2;
1363         u16 uv_x_off, uv_y_off, uv_y_act;
1364         u8 is_pic_yuv = 0;
1365
1366         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
1367         if (win_id < 0)
1368                 return -ENODEV;
1369         else
1370                 win = dev_drv->win[win_id];
1371
1372         if (rk_fb->disp_mode == DUAL) {
1373                 fb_id = get_extend_fb_id(info);
1374                 extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
1375                 extend_fb_par = (struct rk_fb_par *)extend_info->par;
1376                 extend_dev_drv = extend_fb_par->lcdc_drv;
1377                 extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
1378                                                            extend_info->fix.id);
1379                 extend_win = extend_dev_drv->win[extend_win_id];
1380         }
1381
1382         pixel_width = rk_fb_pixel_width(win->format);
1383         vir_width_bit = pixel_width * xvir;
1384         /* pixel_width = byte_num * 8 */
1385         stride_32bit_1 = ALIGN_N_TIMES(vir_width_bit, 32) / 8;
1386         stride_32bit_2 = ALIGN_N_TIMES(vir_width_bit * 2, 32) / 8;
1387
1388         switch (win->format) {
1389         case YUV422:
1390         case YUV422_A:
1391                 is_pic_yuv = 1;
1392                 stride = stride_32bit_1;
1393                 uv_stride = stride_32bit_1 >> 1;
1394                 uv_x_off = xoffset >> 1;
1395                 uv_y_off = yoffset;
1396                 fix->line_length = stride;
1397                 uv_y_act = win->area[0].yact >> 1;
1398                 break;
1399         case YUV420:            /* 420sp */
1400         case YUV420_A:
1401                 is_pic_yuv = 1;
1402                 stride = stride_32bit_1;
1403                 uv_stride = stride_32bit_1;
1404                 uv_x_off = xoffset;
1405                 uv_y_off = yoffset >> 1;
1406                 fix->line_length = stride;
1407                 uv_y_act = win->area[0].yact >> 1;
1408                 break;
1409         case YUV444:
1410         case YUV444_A:
1411                 is_pic_yuv = 1;
1412                 stride = stride_32bit_1;
1413                 uv_stride = stride_32bit_2;
1414                 uv_x_off = xoffset * 2;
1415                 uv_y_off = yoffset;
1416                 fix->line_length = stride << 2;
1417                 uv_y_act = win->area[0].yact;
1418                 break;
1419         default:
1420                 stride = stride_32bit_1;        /* default rgb */
1421                 fix->line_length = stride;
1422                 break;
1423         }
1424
1425         /* x y mirror ,jump line */
1426         if (screen->y_mirror == 1) {
1427                 if (screen->interlace == 1) {
1428                         win->area[0].y_offset = yoffset * stride * 2 +
1429                             ((win->area[0].yact - 1) * 2 + 1) * stride +
1430                             xoffset * pixel_width / 8;
1431                 } else {
1432                         win->area[0].y_offset = yoffset * stride +
1433                             (win->area[0].yact - 1) * stride +
1434                             xoffset * pixel_width / 8;
1435                 }
1436         } else {
1437                 if (screen->interlace == 1) {
1438                         win->area[0].y_offset =
1439                             yoffset * stride * 2 + xoffset * pixel_width / 8;
1440                 } else {
1441                         win->area[0].y_offset =
1442                             yoffset * stride + xoffset * pixel_width / 8;
1443                 }
1444         }
1445         if (is_pic_yuv == 1) {
1446                 if (screen->y_mirror == 1) {
1447                         if (screen->interlace == 1) {
1448                                 win->area[0].c_offset =
1449                                     uv_y_off * uv_stride * 2 +
1450                                     ((uv_y_act - 1) * 2 + 1) * uv_stride +
1451                                     uv_x_off * pixel_width / 8;
1452                         } else {
1453                                 win->area[0].c_offset = uv_y_off * uv_stride +
1454                                     (uv_y_act - 1) * uv_stride +
1455                                     uv_x_off * pixel_width / 8;
1456                         }
1457                 } else {
1458                         if (screen->interlace == 1) {
1459                                 win->area[0].c_offset =
1460                                     uv_y_off * uv_stride * 2 +
1461                                     uv_x_off * pixel_width / 8;
1462                         } else {
1463                                 win->area[0].c_offset =
1464                                     uv_y_off * uv_stride +
1465                                     uv_x_off * pixel_width / 8;
1466                         }
1467                 }
1468         }
1469
1470         win->area[0].smem_start = fix->smem_start;
1471         win->area[0].cbr_start = fix->mmio_start;
1472         win->area[0].state = 1;
1473         win->area_num = 1;
1474
1475         dev_drv->ops->pan_display(dev_drv, win_id);
1476
1477         if (rk_fb->disp_mode == DUAL) {
1478                 if (extend_info != info && extend_win->state &&
1479                     hdmi_switch_complete) {
1480                         rk_fb_set_ext_win_buffer(extend_win, win,
1481                                                  extend_dev_drv->rotate_mode,
1482                                                  extend_dev_drv->iommu_enabled);
1483                         if (extend_dev_drv->rotate_mode > X_Y_MIRROR)
1484                                 rk_fb_rotate(extend_info, info);
1485
1486                         extend_dev_drv->ops->pan_display(extend_dev_drv,
1487                                                          extend_win_id);
1488                         extend_dev_drv->ops->cfg_done(extend_dev_drv);
1489                 }
1490         }
1491 #ifdef  CONFIG_FB_MIRRORING
1492         if (video_data_to_mirroring)
1493                 video_data_to_mirroring(info, NULL);
1494 #endif
1495         dev_drv->ops->cfg_done(dev_drv);
1496         return 0;
1497 }
1498
1499 static int rk_fb_get_list_stat(struct rk_lcdc_driver *dev_drv)
1500 {
1501         int i, j;
1502
1503         i = list_empty(&dev_drv->update_regs_list);
1504         j = list_empty(&saved_list);
1505         return i == j ? 0 : 1;
1506 }
1507
1508 void rk_fd_fence_wait(struct rk_lcdc_driver *dev_drv, struct sync_fence *fence)
1509 {
1510         int err = sync_fence_wait(fence, 1000);
1511
1512         if (err >= 0)
1513                 return;
1514
1515         if (err == -ETIME)
1516                 err = sync_fence_wait(fence, 10 * MSEC_PER_SEC);
1517
1518         if (err < 0)
1519                 printk("error waiting on fence\n");
1520 }
1521 #if 0
1522 static int rk_fb_copy_from_loader(struct fb_info *info)
1523 {
1524         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
1525         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
1526         void *dst = info->screen_base;
1527         u32 dsp_addr[4];
1528         u32 src;
1529         u32 i,size;
1530         int win_id;
1531         struct rk_lcdc_win *win;
1532
1533         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
1534         win = dev_drv->win[win_id];
1535         size = (win->area[0].xact) * (win->area[0].yact) << 2;
1536         dev_drv->ops->get_dsp_addr(dev_drv, dsp_addr);
1537         src = dsp_addr[win_id];
1538         dev_info(info->dev, "copy fb data %d x %d  from  dst_addr:%08x\n",
1539                  win->area[0].xact, win->area[0].yact, src);
1540         for (i = 0; i < size; i += PAGE_SIZE) {
1541                 void *page = phys_to_page(i + src);
1542                 void *from_virt = kmap(page);
1543                 void *to_virt = dst + i;
1544                 memcpy(to_virt, from_virt, PAGE_SIZE);
1545         }
1546         dev_drv->ops->direct_set_addr(dev_drv, win_id,
1547                                       info->fix.smem_start);
1548         return 0;
1549 }
1550 #endif
1551 #ifdef CONFIG_ROCKCHIP_IOMMU
1552 static int g_last_addr[4];
1553 int g_last_timeout;
1554 u32 freed_addr[10];
1555 u32 freed_index;
1556
1557 #define DUMP_CHUNK 256
1558 char buf[PAGE_SIZE];
1559
1560 int rk_fb_sysmmu_fault_handler(struct device *dev,
1561                                enum rk_iommu_inttype itype,
1562                                unsigned long pgtable_base,
1563                                unsigned long fault_addr, unsigned int status)
1564 {
1565         struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
1566         int i = 0;
1567         static int page_fault_cnt;
1568         if ((page_fault_cnt++) >= 10)
1569                 return 0;
1570         pr_err
1571             ("PAGE FAULT occurred at 0x%lx (Page table base: 0x%lx),status=%d\n",
1572              fault_addr, pgtable_base, status);
1573         printk("last config addr:\n" "win0:0x%08x\n" "win1:0x%08x\n"
1574                "win2:0x%08x\n" "win3:0x%08x\n", g_last_addr[0], g_last_addr[1],
1575                g_last_addr[2], g_last_addr[3]);
1576         printk("last freed buffer:\n");
1577         for (i = 0; (freed_addr[i] != 0xfefefefe) && freed_addr[i]; i++)
1578                 printk("%d:0x%08x\n", i, freed_addr[i]);
1579         printk("last timeout:%d\n", g_last_timeout);
1580         dev_drv->ops->get_disp_info(dev_drv, buf, 0);
1581         for (i = 0; i < PAGE_SIZE; i += DUMP_CHUNK) {
1582                 if ((PAGE_SIZE - i) > DUMP_CHUNK) {
1583                         char c = buf[i + DUMP_CHUNK];
1584                         buf[i + DUMP_CHUNK] = 0;
1585                         pr_cont("%s", buf + i);
1586                         buf[i + DUMP_CHUNK] = c;
1587                 } else {
1588                         buf[PAGE_SIZE - 1] = 0;
1589                         pr_cont("%s", buf + i);
1590                 }
1591         }
1592
1593         return 0;
1594 }
1595 #endif
1596
1597 void rk_fb_free_dma_buf(struct rk_lcdc_driver *dev_drv,
1598                         struct rk_fb_reg_win_data *reg_win_data)
1599 {
1600         int i, index_buf;
1601         struct rk_fb_reg_area_data *area_data;
1602         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
1603 #if defined(CONFIG_ROCKCHIP_IOMMU)
1604         struct rk_lcdc_driver *ext_dev_drv = rk_get_extend_lcdc_drv();
1605 #endif
1606
1607         for (i = 0; i < reg_win_data->area_num; i++) {
1608                 area_data = &reg_win_data->reg_area_data[i];
1609                 index_buf = area_data->index_buf;
1610 #if defined(CONFIG_ROCKCHIP_IOMMU)
1611                 if (dev_drv->iommu_enabled) {
1612                         if (rk_fb->disp_policy != DISPLAY_POLICY_BOX)
1613                         ion_unmap_iommu(dev_drv->dev, rk_fb->ion_client,
1614                                         area_data->ion_handle);
1615                         freed_addr[freed_index++] = area_data->smem_start;
1616                 }
1617                 if (rk_fb->disp_mode == DUAL && hdmi_switch_complete) {
1618                         if (ext_dev_drv->iommu_enabled)
1619                                 ion_unmap_iommu(ext_dev_drv->dev,
1620                                                 rk_fb->ion_client,
1621                                                 area_data->ion_handle);
1622                 }
1623 #endif
1624                 if (area_data->ion_handle != NULL) {
1625                         ion_unmap_kernel(rk_fb->ion_client,
1626                                          area_data->ion_handle);
1627                         ion_free(rk_fb->ion_client, area_data->ion_handle);
1628                 }
1629                 if (area_data->acq_fence)
1630                         sync_fence_put(area_data->acq_fence);
1631         }
1632         memset(reg_win_data, 0, sizeof(struct rk_fb_reg_win_data));
1633 }
1634
1635 /*
1636  * function: update extend win info acorrding to primary win info,
1637         the function is only used for dual display mode
1638  * @ext_dev_drv: the extend lcdc driver
1639  * @dev_drv: the primary lcdc driver
1640  * @ext_win: the lcdc win info of extend screen
1641  * @win: the lcdc win info of primary screen
1642  */
1643 static int rk_fb_update_ext_win(struct rk_lcdc_driver *ext_dev_drv,
1644                                      struct rk_lcdc_driver *dev_drv,
1645                                      struct rk_lcdc_win *ext_win,
1646                                      struct rk_lcdc_win *win)
1647 {
1648         struct rk_screen *screen = dev_drv->cur_screen;
1649         struct rk_screen *ext_screen = ext_dev_drv->cur_screen;
1650         int hdmi_xsize = ext_screen->xsize;
1651         int hdmi_ysize = ext_screen->ysize;
1652         int pixel_width, vir_width_bit, y_stride;
1653         bool is_yuv = false;
1654         int rotate_mode = 0;
1655
1656         if (unlikely(!dev_drv) || unlikely(!ext_dev_drv) ||
1657             unlikely(!ext_win) || unlikely(!win))
1658                 return -1;
1659
1660         rotate_mode = ext_dev_drv->rotate_mode;
1661
1662         if (ext_win->state == 0) {
1663                 dev_info(ext_dev_drv->dev, "extend lcdc win is closed\n");
1664                 return 0;
1665         }
1666
1667         ext_win->area[0].state = win->area[0].state;
1668         ext_win->area_num = win->area_num;
1669         ext_win->format = win->format;
1670         ext_win->fmt_10 = win->fmt_10;
1671         ext_win->z_order = win->z_order;
1672         ext_win->alpha_en = win->alpha_en;
1673         ext_win->alpha_mode = win->alpha_mode;
1674         ext_win->g_alpha_val = win->g_alpha_val;
1675
1676         switch (ext_win->format) {
1677         case YUV422:
1678         case YUV420:
1679         case YUV444:
1680         case YUV422_A:
1681         case YUV420_A:
1682         case YUV444_A:
1683                 is_yuv = true;
1684                 break;
1685         default:
1686                 is_yuv = false;
1687                 break;
1688         }
1689
1690         if (rotate_mode == ROTATE_90 || rotate_mode == ROTATE_270) {
1691                 ext_win->area[0].xact = win->area[0].yact;
1692                 ext_win->area[0].yact = win->area[0].xact;
1693                 ext_win->area[0].xvir = win->area[0].yact;
1694                 ext_win->area[0].yvir = win->area[0].xact;
1695
1696                 pixel_width = rk_fb_pixel_width(ext_win->format);
1697                 vir_width_bit = pixel_width * ext_win->area[0].xvir;
1698                 y_stride = ALIGN_N_TIMES(vir_width_bit, 32) / 8;
1699                 ext_win->area[0].y_vir_stride = y_stride >> 2;
1700                 if (is_yuv)
1701                         ext_win->area[0].uv_vir_stride = ext_win->area[0].y_vir_stride;
1702                 else
1703                         ext_win->area[0].uv_vir_stride = 0;
1704         } else {
1705                 ext_win->area[0].xact = win->area[0].xact;
1706                 ext_win->area[0].yact = win->area[0].yact;
1707                 if (win->area[0].xvir == 0)
1708                         ext_win->area[0].xvir = win->area[0].xact;
1709                 else
1710                         ext_win->area[0].xvir = win->area[0].xvir;
1711                 if (win->area[0].yvir == 0)
1712                         ext_win->area[0].yvir = win->area[0].yact;
1713                 else
1714                         ext_win->area[0].yvir = win->area[0].yvir;
1715                 ext_win->area[0].y_vir_stride = win->area[0].y_vir_stride;
1716                 if (is_yuv)
1717                         ext_win->area[0].uv_vir_stride = win->area[0].uv_vir_stride;
1718                 else
1719                         ext_win->area[0].uv_vir_stride = 0;
1720         }
1721
1722         if (win->area[0].xpos != 0 || win->area[0].ypos != 0) {
1723                 if (rotate_mode == ROTATE_270) {
1724                         int xbom_pos = 0, ybom_pos = 0;
1725                         int xtop_pos = 0, ytop_pos = 0;
1726
1727                         ext_win->area[0].xsize =
1728                                 hdmi_xsize * win->area[0].ysize / screen->mode.yres;
1729                         ext_win->area[0].ysize =
1730                                 hdmi_ysize * win->area[0].xsize / screen->mode.xres;
1731                         xbom_pos =
1732                                 hdmi_xsize * win->area[0].ypos / screen->mode.yres;
1733                         ybom_pos = hdmi_ysize * win->area[0].xpos / screen->mode.xres;
1734                         xtop_pos = hdmi_xsize - ext_win->area[0].xsize - xbom_pos;
1735                         ytop_pos = hdmi_ysize - ext_win->area[0].ysize - ybom_pos;
1736                         ext_win->area[0].xpos =
1737                                 ((ext_screen->mode.xres - hdmi_xsize) >> 1) + xtop_pos;
1738                         ext_win->area[0].ypos =
1739                                 ((ext_screen->mode.yres - hdmi_ysize) >> 1) + ytop_pos;
1740                 } else if (rotate_mode == ROTATE_90) {
1741                         ext_win->area[0].xsize =
1742                                 hdmi_xsize * win->area[0].ysize / screen->mode.yres;
1743                         ext_win->area[0].ysize =
1744                                 hdmi_ysize * win->area[0].xsize / screen->mode.xres;
1745                         ext_win->area[0].xpos =
1746                                 ((ext_screen->mode.xres - hdmi_xsize) >> 1) +
1747                                 hdmi_xsize * win->area[0].ypos / screen->mode.yres;
1748                         ext_win->area[0].ypos =
1749                                 ((ext_screen->mode.yres - hdmi_ysize) >> 1) +
1750                                 hdmi_ysize * win->area[0].xpos / screen->mode.xres;
1751                 } else {
1752                         ext_win->area[0].xsize =
1753                                 hdmi_xsize * win->area[0].xsize / screen->mode.xres;
1754                         ext_win->area[0].ysize =
1755                                 hdmi_ysize * win->area[0].ysize / screen->mode.yres;
1756                         ext_win->area[0].xpos =
1757                                 ((ext_screen->mode.xres - hdmi_xsize) >> 1) +
1758                                 hdmi_xsize * win->area[0].xpos / screen->mode.xres;
1759                         ext_win->area[0].ypos =
1760                                 ((ext_screen->mode.yres - hdmi_ysize) >> 1) +
1761                                 hdmi_ysize * win->area[0].ypos / screen->mode.yres;
1762                 }
1763         } else {
1764                 ext_win->area[0].xsize = hdmi_xsize;
1765                 ext_win->area[0].ysize = hdmi_ysize;
1766                 ext_win->area[0].xpos =
1767                         (ext_screen->mode.xres - hdmi_xsize) >> 1;
1768                 ext_win->area[0].ypos =
1769                         (ext_screen->mode.yres - hdmi_ysize) >> 1;
1770         }
1771
1772         return 0;
1773 }
1774
1775 static void rk_fb_update_win(struct rk_lcdc_driver *dev_drv,
1776                                 struct rk_lcdc_win *win,
1777                                 struct rk_fb_reg_win_data *reg_win_data)
1778 {
1779         int i = 0;
1780         struct rk_fb *inf = platform_get_drvdata(fb_pdev);
1781         struct rk_screen *cur_screen;
1782         struct rk_screen primary_screen;
1783
1784         if (unlikely(!inf) || unlikely(!dev_drv) ||
1785             unlikely(!win) || unlikely(!reg_win_data))
1786                 return;
1787
1788         cur_screen = dev_drv->cur_screen;
1789         rk_fb_get_prmry_screen(&primary_screen);
1790
1791         win->area_num = reg_win_data->area_num;
1792         win->format = reg_win_data->data_format;
1793         win->id = reg_win_data->win_id;
1794         win->z_order = reg_win_data->z_order;
1795
1796         if (reg_win_data->reg_area_data[0].smem_start > 0) {
1797                 win->state = 1;
1798                 win->area_num = reg_win_data->area_num;
1799                 win->format = reg_win_data->data_format;
1800                 win->id = reg_win_data->win_id;
1801                 win->z_order = reg_win_data->z_order;
1802                 win->area[0].uv_vir_stride =
1803                     reg_win_data->reg_area_data[0].uv_vir_stride;
1804                 win->area[0].cbr_start =
1805                     reg_win_data->reg_area_data[0].cbr_start;
1806                 win->area[0].c_offset = reg_win_data->reg_area_data[0].c_offset;
1807                 win->alpha_en = reg_win_data->alpha_en;
1808                 win->alpha_mode = reg_win_data->alpha_mode;
1809                 win->g_alpha_val = reg_win_data->g_alpha_val;
1810                 for (i = 0; i < RK_WIN_MAX_AREA; i++) {
1811                         if (reg_win_data->reg_area_data[i].smem_start > 0) {
1812                                 if (inf->disp_policy != DISPLAY_POLICY_BOX)
1813                                         win->area[i].ion_hdl =
1814                                         reg_win_data->reg_area_data[i].ion_handle;
1815                                 win->area[i].smem_start =
1816                                         reg_win_data->reg_area_data[i].smem_start;
1817                                 if (inf->disp_mode == DUAL ||
1818                                     inf->disp_policy == DISPLAY_POLICY_BOX) {
1819                                         win->area[i].xpos =
1820                                                 reg_win_data->reg_area_data[i].xpos;
1821                                         win->area[i].ypos =
1822                                                 reg_win_data->reg_area_data[i].ypos;
1823                                         win->area[i].xsize =
1824                                                 reg_win_data->reg_area_data[i].xsize;
1825                                         win->area[i].ysize =
1826                                                 reg_win_data->reg_area_data[i].ysize;
1827                                 } else {
1828                                         win->area[i].xpos =
1829                                                 reg_win_data->reg_area_data[i].xpos *
1830                                                 cur_screen->mode.xres /
1831                                                 primary_screen.mode.xres;
1832                                         win->area[i].ypos =
1833                                                 reg_win_data->reg_area_data[i].ypos *
1834                                                 cur_screen->mode.yres /
1835                                                 primary_screen.mode.yres;
1836                                         win->area[i].xsize =
1837                                                 reg_win_data->reg_area_data[i].xsize *
1838                                                 cur_screen->mode.xres /
1839                                                 primary_screen.mode.xres;
1840                                         win->area[i].ysize =
1841                                                 reg_win_data->reg_area_data[i].ysize *
1842                                                 cur_screen->mode.yres /
1843                                                 primary_screen.mode.yres;
1844
1845                                         /* recalc display size if set hdmi scaler when at ONE_DUAL mode */
1846                                         if (inf->disp_mode == ONE_DUAL && hdmi_switch_complete) {
1847                                                 if (cur_screen->xsize > 0 &&
1848                                                     cur_screen->xsize <= cur_screen->mode.xres) {
1849                                                         win->area[i].xpos =
1850                                                                 ((cur_screen->mode.xres - cur_screen->xsize) >> 1) +
1851                                                                 cur_screen->xsize * win->area[i].xpos / cur_screen->mode.xres;
1852                                                         win->area[i].xsize =
1853                                                                 win->area[i].xsize * cur_screen->xsize / cur_screen->mode.xres;
1854                                                 }
1855                                                 if (cur_screen->ysize > 0 && cur_screen->ysize <= cur_screen->mode.yres) {
1856                                                         win->area[i].ypos =
1857                                                                 ((cur_screen->mode.yres - cur_screen->ysize) >> 1) +
1858                                                                 cur_screen->ysize * win->area[i].ypos / cur_screen->mode.yres;
1859                                                         win->area[i].ysize =
1860                                                                 win->area[i].ysize * cur_screen->ysize / cur_screen->mode.yres;
1861                                                 }
1862                                         }
1863                                 }
1864                                 win->area[i].xact =
1865                                     reg_win_data->reg_area_data[i].xact;
1866                                 win->area[i].yact =
1867                                     reg_win_data->reg_area_data[i].yact;
1868                                 win->area[i].xvir =
1869                                     reg_win_data->reg_area_data[i].xvir;
1870                                 win->area[i].yvir =
1871                                     reg_win_data->reg_area_data[i].yvir;
1872                                 win->area[i].y_offset =
1873                                     reg_win_data->reg_area_data[i].y_offset;
1874                                 win->area[i].y_vir_stride =
1875                                     reg_win_data->reg_area_data[i].y_vir_stride;
1876                                 win->area[i].state = 1;
1877                         } else {
1878                                 win->area[i].state = 0;
1879                         }
1880                 }
1881         } else {
1882         /*
1883                 win->state = 0;
1884                 win->z_order = -1;
1885         */
1886         }
1887 }
1888
1889 static struct rk_fb_reg_win_data *rk_fb_get_win_data(struct rk_fb_reg_data
1890                                                      *regs, int win_id)
1891 {
1892         int i;
1893         struct rk_fb_reg_win_data *win_data = NULL;
1894         for (i = 0; i < regs->win_num; i++) {
1895                 if (regs->reg_win_data[i].win_id == win_id) {
1896                         win_data = &(regs->reg_win_data[i]);
1897                         break;
1898                 }
1899         }
1900
1901         return win_data;
1902 }
1903
1904 static void rk_fb_update_reg(struct rk_lcdc_driver *dev_drv,
1905                              struct rk_fb_reg_data *regs)
1906 {
1907         int i, j;
1908         struct rk_lcdc_win *win;
1909         ktime_t timestamp = dev_drv->vsync_info.timestamp;
1910         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
1911         struct rk_lcdc_driver *ext_dev_drv;
1912         struct rk_lcdc_win *ext_win;
1913         struct rk_fb_reg_win_data *win_data;
1914         bool wait_for_vsync;
1915         int count = 100;
1916         unsigned int dsp_addr[4];
1917         long timeout;
1918
1919         /* acq_fence wait */
1920         for (i = 0; i < regs->win_num; i++) {
1921                 win_data = &regs->reg_win_data[i];
1922                 for (j = 0; j < RK_WIN_MAX_AREA; j++) {
1923                         if (win_data->reg_area_data[j].acq_fence) {
1924                                 /* printk("acq_fence wait!!!!!\n"); */
1925                                 rk_fd_fence_wait(dev_drv, win_data->reg_area_data[j].acq_fence);
1926                         }
1927                 }
1928         }
1929
1930         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
1931                 win = dev_drv->win[i];
1932                 win_data = rk_fb_get_win_data(regs, i);
1933                 if (win_data) {
1934                         if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
1935                              win_data->data_format == YUV420)
1936                                 continue;
1937                         rk_fb_update_win(dev_drv, win, win_data);
1938                         win->state = 1;
1939                         dev_drv->ops->set_par(dev_drv, i);
1940                         dev_drv->ops->pan_display(dev_drv, i);
1941 #if defined(CONFIG_ROCKCHIP_IOMMU)
1942                         if (dev_drv->iommu_enabled) {
1943                                 g_last_addr[i] = win_data->reg_area_data[0].smem_start +
1944                                         win_data->reg_area_data[0].y_offset;
1945                         }
1946 #endif
1947                 } else {
1948                         win->z_order = -1;
1949                         win->state = 0;
1950                 }
1951         }
1952         dev_drv->ops->ovl_mgr(dev_drv, 0, 1);
1953         if (rk_fb->disp_policy == DISPLAY_POLICY_BOX)
1954                 dev_drv->ops->cfg_done(dev_drv);
1955         if ((rk_fb->disp_mode == DUAL)
1956             && (hdmi_get_hotplug() == HDMI_HPD_ACTIVED)
1957             && hdmi_switch_complete) {
1958                 ext_dev_drv = rk_get_extend_lcdc_drv();
1959                 if (!ext_dev_drv) {
1960                         printk(KERN_ERR "hdmi lcdc driver not found!\n");
1961                         goto ext_win_exit;
1962                 }
1963
1964                 /*
1965                   * For RK3288: win0 and win1 have only one area and support scale
1966                   * but win2 and win3 don't support scale
1967                   * so hdmi only use win0 or win1
1968                   */
1969                 for (i = 0; i < 2; i++) {
1970                         win = dev_drv->win[i];
1971                         ext_win = ext_dev_drv->win[i];
1972                         ext_win->state = win->state;
1973                         ext_win->id = win->id;
1974                         if (!ext_win->state)
1975                                 continue;
1976                         rk_fb_update_ext_win(ext_dev_drv, dev_drv, ext_win, win);
1977                         rk_fb_set_ext_win_buffer(ext_win, win,
1978                                                  ext_dev_drv->rotate_mode,
1979                                                  ext_dev_drv->iommu_enabled);
1980
1981                         if (ext_dev_drv->rotate_mode > X_Y_MIRROR)
1982                                 rk_fb_win_rotate(ext_win, win,
1983                                                  ext_dev_drv->rotate_mode,
1984                                                  ext_dev_drv->iommu_enabled);
1985
1986                         ext_dev_drv->ops->set_par(ext_dev_drv, i);
1987                         ext_dev_drv->ops->pan_display(ext_dev_drv, i);
1988                 }
1989
1990                 ext_dev_drv->ops->cfg_done(ext_dev_drv);
1991         }
1992 ext_win_exit:
1993         dev_drv->ops->cfg_done(dev_drv);
1994
1995         do {
1996                 timestamp = dev_drv->vsync_info.timestamp;
1997                 timeout = wait_event_interruptible_timeout(dev_drv->vsync_info.wait,
1998                                 ktime_compare(dev_drv->vsync_info.timestamp, timestamp) > 0,
1999                                 msecs_to_jiffies(25));
2000                 dev_drv->ops->get_dsp_addr(dev_drv, dsp_addr);
2001                 wait_for_vsync = false;
2002                 for (i = 0; i < dev_drv->lcdc_win_num; i++) {
2003                         if (dev_drv->win[i]->state == 1) {
2004                                 if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
2005                                     (dev_drv->win[i]->format == YUV420 ||
2006                                      !strcmp(dev_drv->win[i]->name, "hwc"))) {
2007                                         continue;
2008                                 } else {
2009                                         u32 new_start =
2010                                             dev_drv->win[i]->area[0].smem_start +
2011                                             dev_drv->win[i]->area[0].y_offset;
2012                                         u32 reg_start = dsp_addr[i];
2013
2014                                         if ((rk_fb->disp_policy ==
2015                                              DISPLAY_POLICY_BOX) &&
2016                                             (new_start == 0x0 ||
2017                                              dev_drv->suspend_flag))
2018                                                 continue;
2019                                         if (unlikely(new_start != reg_start)) {
2020                                                 wait_for_vsync = true;
2021                                                 dev_info(dev_drv->dev,
2022                                                        "win%d:new_addr:0x%08x cur_addr:0x%08x--%d\n",
2023                                                        i, new_start, reg_start, 101 - count);
2024                                                 break;
2025                                         }
2026                                 }
2027                         }
2028                 }
2029         } while (wait_for_vsync && count--);
2030 #ifdef H_USE_FENCE
2031         sw_sync_timeline_inc(dev_drv->timeline, 1);
2032 #endif
2033         if (!g_first_buf) {
2034 #if defined(CONFIG_ROCKCHIP_IOMMU)
2035                 if (dev_drv->iommu_enabled) {
2036                         freed_index = 0;
2037                         g_last_timeout = timeout;
2038                 }
2039 #endif
2040                 for (i = 0; i < g_last_win_num; i++)
2041                         rk_fb_free_dma_buf(dev_drv, &g_reg_win_data[i]);
2042
2043 #if defined(CONFIG_ROCKCHIP_IOMMU)
2044                 if (dev_drv->iommu_enabled)
2045                         freed_addr[freed_index] = 0xfefefefe;
2046 #endif
2047         }
2048         for (i = 0; i < regs->win_num; i++) {
2049                 memcpy(&g_reg_win_data[i], &(regs->reg_win_data[i]),
2050                        sizeof(struct rk_fb_reg_win_data));
2051         }
2052         g_last_win_num = regs->win_num;
2053         g_first_buf = 0;
2054 }
2055
2056 static void rk_fb_update_regs_handler(struct kthread_work *work)
2057 {
2058         struct rk_lcdc_driver *dev_drv =
2059             container_of(work, struct rk_lcdc_driver, update_regs_work);
2060         struct rk_fb_reg_data *data, *next;
2061         /* struct list_head saved_list; */
2062
2063         mutex_lock(&dev_drv->update_regs_list_lock);
2064         saved_list = dev_drv->update_regs_list;
2065         list_replace_init(&dev_drv->update_regs_list, &saved_list);
2066         mutex_unlock(&dev_drv->update_regs_list_lock);
2067
2068         list_for_each_entry_safe(data, next, &saved_list, list) {
2069                 rk_fb_update_reg(dev_drv, data);
2070                 list_del(&data->list);
2071                 kfree(data);
2072         }
2073
2074         if (dev_drv->wait_fs && list_empty(&dev_drv->update_regs_list))
2075                 wake_up(&dev_drv->update_regs_wait);
2076 }
2077
2078 static int rk_fb_check_config_var(struct rk_fb_area_par *area_par,
2079                                   struct rk_screen *screen)
2080 {
2081         if ((area_par->x_offset + area_par->xact > area_par->xvir) ||
2082             (area_par->xact <= 0) || (area_par->yact <= 0) ||
2083             (area_par->xvir <= 0) || (area_par->yvir <= 0)) {
2084                 pr_err("check config var fail 0:\n"
2085                        "x_offset=%d,xact=%d,xvir=%d\n",
2086                        area_par->x_offset, area_par->xact, area_par->xvir);
2087                 return -EINVAL;
2088         }
2089
2090         if ((area_par->xpos + area_par->xsize > screen->mode.xres) ||
2091             (area_par->ypos + area_par->ysize > screen->mode.yres) ||
2092             (area_par->xsize <= 0) || (area_par->ysize <= 0)) {
2093                 pr_err("check config var fail 1:\n"
2094                        "xpos=%d,xsize=%d,xres=%d\n"
2095                        "ypos=%d,ysize=%d,yres=%d\n",
2096                        area_par->xpos, area_par->xsize, screen->mode.xres,
2097                        area_par->ypos, area_par->ysize, screen->mode.yres);
2098                 return -EINVAL;
2099         }
2100         return 0;
2101 }
2102
2103 static int rk_fb_set_win_buffer(struct fb_info *info,
2104                                 struct rk_fb_win_par *win_par,
2105                                 struct rk_fb_reg_win_data *reg_win_data)
2106 {
2107         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
2108         struct fb_fix_screeninfo *fix = &info->fix;
2109         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2110         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2111         struct rk_screen *screen = dev_drv->cur_screen;
2112         struct rk_screen primary_screen;
2113         struct fb_info *fbi = rk_fb->fb[0];
2114         int i, ion_fd, acq_fence_fd;
2115         u32 xvir, yvir;
2116         u32 xoffset, yoffset;
2117
2118         struct ion_handle *hdl;
2119         size_t len;
2120         int index_buf;
2121         u8 fb_data_fmt;
2122         u8 pixel_width;
2123         u32 vir_width_bit;
2124         u32 stride, uv_stride;
2125         u32 stride_32bit_1;
2126         u32 stride_32bit_2;
2127         u16 uv_x_off, uv_y_off, uv_y_act;
2128         u8 is_pic_yuv = 0;
2129         u8 ppixel_a = 0, global_a = 0;
2130         ion_phys_addr_t phy_addr;
2131         int ret = 0;
2132
2133         reg_win_data->reg_area_data[0].smem_start = -1;
2134         reg_win_data->area_num = 0;
2135         fbi = rk_fb->fb[reg_win_data->win_id];
2136         if (win_par->area_par[0].phy_addr == 0) {
2137                 for (i = 0; i < RK_WIN_MAX_AREA; i++) {
2138                         ion_fd = win_par->area_par[i].ion_fd;
2139                         if (ion_fd > 0) {
2140                                 hdl =
2141                                     ion_import_dma_buf(rk_fb->ion_client,
2142                                                        ion_fd);
2143                                 if (IS_ERR(hdl)) {
2144                                         pr_info
2145                                             ("%s: Could not import handle: %d\n",
2146                                              __func__, (int)hdl);
2147                                         /*return -EINVAL; */
2148                                         break;
2149                                 }
2150                                 fbi->screen_base =
2151                                     ion_map_kernel(rk_fb->ion_client, hdl);
2152                                 reg_win_data->area_num++;
2153                                 reg_win_data->reg_area_data[i].ion_handle = hdl;
2154 #ifndef CONFIG_ROCKCHIP_IOMMU
2155                                 ret = ion_phys(rk_fb->ion_client, hdl, &phy_addr,
2156                                                 &len);
2157 #else
2158                                 if (dev_drv->iommu_enabled)
2159                                         ret = ion_map_iommu(dev_drv->dev,
2160                                                                 rk_fb->ion_client,
2161                                                                 hdl,
2162                                                                 (unsigned long *)&phy_addr,
2163                                                                 (unsigned long *)&len);
2164                                 else
2165                                         ret = ion_phys(rk_fb->ion_client, hdl,
2166                                                         &phy_addr, &len);
2167 #endif
2168                                 if (ret < 0) {
2169                                         dev_err(fbi->dev, "ion map to get phy addr failed\n");
2170                                         ion_free(rk_fb->ion_client, hdl);
2171                                         return -ENOMEM;
2172                                 }
2173                                 reg_win_data->reg_area_data[i].smem_start = phy_addr;
2174                                 reg_win_data->area_buf_num++;
2175                                 reg_win_data->reg_area_data[i].index_buf = 1;
2176                         }
2177                 }
2178         } else {
2179                 reg_win_data->reg_area_data[0].smem_start =
2180                     win_par->area_par[0].phy_addr;
2181                 reg_win_data->area_num = 1;
2182                 fbi->screen_base = phys_to_virt(win_par->area_par[0].phy_addr);
2183         }
2184
2185         if (reg_win_data->area_num == 0)
2186                 return 0;
2187
2188         for (i = 0; i < reg_win_data->area_num; i++) {
2189                 acq_fence_fd = win_par->area_par[i].acq_fence_fd;
2190                 index_buf = reg_win_data->reg_area_data[i].index_buf;
2191                 if ((acq_fence_fd > 0) && (index_buf == 1)) {
2192                         reg_win_data->reg_area_data[i].acq_fence =
2193                             sync_fence_fdget(win_par->area_par[i].acq_fence_fd);
2194                 }
2195         }
2196         fb_data_fmt = rk_fb_data_fmt(win_par->data_format, 0);
2197         reg_win_data->data_format = fb_data_fmt;
2198         pixel_width = rk_fb_pixel_width(fb_data_fmt);
2199
2200         ppixel_a = ((fb_data_fmt == ARGB888) ||
2201                     (fb_data_fmt == ABGR888)) ? 1 : 0;
2202         global_a = (win_par->g_alpha_val == 0) ? 0 : 1;
2203         reg_win_data->alpha_en = ppixel_a | global_a;
2204         reg_win_data->g_alpha_val = win_par->g_alpha_val;
2205         reg_win_data->alpha_mode = win_par->alpha_mode;
2206         if (reg_win_data->reg_area_data[0].smem_start > 0) {
2207                 reg_win_data->z_order = win_par->z_order;
2208                 reg_win_data->win_id = win_par->win_id;
2209         } else {
2210                 reg_win_data->z_order = -1;
2211                 reg_win_data->win_id = -1;
2212         }
2213
2214         rk_fb_get_prmry_screen(&primary_screen);
2215         for (i = 0; i < reg_win_data->area_num; i++) {
2216                 if (rk_fb->disp_policy == DISPLAY_POLICY_BOX)
2217                         rk_fb_check_config_var(&win_par->area_par[i], screen);
2218                 else
2219                         rk_fb_check_config_var(&win_par->area_par[i], &primary_screen);
2220                 /* visiable pos in panel */
2221                 reg_win_data->reg_area_data[i].xpos = win_par->area_par[i].xpos;
2222                 reg_win_data->reg_area_data[i].ypos = win_par->area_par[i].ypos;
2223
2224                 /* realy size in panel */
2225                 reg_win_data->reg_area_data[i].xsize = win_par->area_par[i].xsize;
2226                 reg_win_data->reg_area_data[i].ysize = win_par->area_par[i].ysize;
2227
2228                 /* realy size in panel */
2229                 reg_win_data->reg_area_data[i].xact = win_par->area_par[i].xact;
2230                 reg_win_data->reg_area_data[i].yact = win_par->area_par[i].yact;
2231
2232                 xoffset = win_par->area_par[i].x_offset;        /* buf offset */
2233                 yoffset = win_par->area_par[i].y_offset;
2234                 xvir = win_par->area_par[i].xvir;
2235                 reg_win_data->reg_area_data[i].xvir = xvir;
2236                 yvir = win_par->area_par[i].yvir;
2237                 reg_win_data->reg_area_data[i].yvir = yvir;
2238
2239                 vir_width_bit = pixel_width * xvir;
2240                 /* pixel_width = byte_num*8 */
2241                 stride_32bit_1 = ((vir_width_bit + 31) & (~31)) / 8;
2242                 stride_32bit_2 = ((vir_width_bit * 2 + 31) & (~31)) / 8;
2243
2244                 stride = stride_32bit_1;        /* default rgb */
2245                 fix->line_length = stride;
2246                 reg_win_data->reg_area_data[i].y_vir_stride = stride >> 2;
2247
2248                 /* x y mirror ,jump line
2249                  * reg_win_data->reg_area_data[i].y_offset =
2250                  *              yoffset*stride+xoffset*pixel_width/8;
2251                  */
2252                 if (screen->y_mirror == 1) {
2253                         if (screen->interlace == 1) {
2254                                 reg_win_data->reg_area_data[i].y_offset =
2255                                     yoffset * stride * 2 +
2256                                     ((reg_win_data->reg_area_data[i].yact - 1) * 2 + 1) * stride +
2257                                     xoffset * pixel_width / 8;
2258                         } else {
2259                                 reg_win_data->reg_area_data[i].y_offset =
2260                                     yoffset * stride +
2261                                     (reg_win_data->reg_area_data[i].yact - 1) * stride +
2262                                     xoffset * pixel_width / 8;
2263                         }
2264                 } else {
2265                         if (screen->interlace == 1) {
2266                                 reg_win_data->reg_area_data[i].y_offset =
2267                                     yoffset * stride * 2 +
2268                                     xoffset * pixel_width / 8;
2269                         } else {
2270                                 reg_win_data->reg_area_data[i].y_offset =
2271                                     yoffset * stride +
2272                                     xoffset * pixel_width / 8;
2273                         }
2274                 }
2275         }
2276         switch (fb_data_fmt) {
2277         case YUV422:
2278         case YUV422_A:
2279                 is_pic_yuv = 1;
2280                 stride = stride_32bit_1;
2281                 uv_stride = stride_32bit_1 >> 1;
2282                 uv_x_off = xoffset >> 1;
2283                 uv_y_off = yoffset;
2284                 fix->line_length = stride;
2285                 uv_y_act = win_par->area_par[0].yact >> 1;
2286                 break;
2287         case YUV420:            /* 420sp */
2288         case YUV420_A:
2289                 is_pic_yuv = 1;
2290                 stride = stride_32bit_1;
2291                 uv_stride = stride_32bit_1;
2292                 uv_x_off = xoffset;
2293                 uv_y_off = yoffset >> 1;
2294                 fix->line_length = stride;
2295                 uv_y_act = win_par->area_par[0].yact >> 1;
2296                 break;
2297         case YUV444:
2298         case YUV444_A:
2299                 is_pic_yuv = 1;
2300                 stride = stride_32bit_1;
2301                 uv_stride = stride_32bit_2;
2302                 uv_x_off = xoffset * 2;
2303                 uv_y_off = yoffset;
2304                 fix->line_length = stride << 2;
2305                 uv_y_act = win_par->area_par[0].yact;
2306                 break;
2307         default:
2308                 break;
2309         }
2310         if (is_pic_yuv == 1) {
2311                 reg_win_data->reg_area_data[0].cbr_start =
2312                     reg_win_data->reg_area_data[0].smem_start + xvir * yvir;
2313                 reg_win_data->reg_area_data[0].uv_vir_stride = uv_stride >> 2;
2314                 if (screen->y_mirror == 1) {
2315                         if (screen->interlace == 1) {
2316                                 reg_win_data->reg_area_data[0].c_offset =
2317                                     uv_y_off * uv_stride * 2 +
2318                                     ((uv_y_act - 1) * 2 + 1) * uv_stride +
2319                                     uv_x_off * pixel_width / 8;
2320                         } else {
2321                                 reg_win_data->reg_area_data[0].c_offset =
2322                                     uv_y_off * uv_stride +
2323                                     (uv_y_act - 1) * uv_stride +
2324                                     uv_x_off * pixel_width / 8;
2325                         }
2326                 } else {
2327                         if (screen->interlace == 1) {
2328                                 reg_win_data->reg_area_data[0].c_offset =
2329                                     uv_y_off * uv_stride * 2 +
2330                                     uv_x_off * pixel_width / 8;
2331                         } else {
2332                                 reg_win_data->reg_area_data[0].c_offset =
2333                                     uv_y_off * uv_stride +
2334                                     uv_x_off * pixel_width / 8;
2335                         }
2336                 }
2337         }
2338
2339         /* record buffer information for rk_fb_disp_scale to prevent fence timeout
2340          * because rk_fb_disp_scale will call function info->fbops->fb_set_par(info);
2341          */
2342         fix->smem_start = reg_win_data->reg_area_data[0].smem_start;
2343         info->var.yoffset = yoffset;
2344         info->var.xoffset = xoffset;
2345         return 0;
2346 }
2347
2348 static int rk_fb_set_win_config(struct fb_info *info,
2349                                 struct rk_fb_win_cfg_data *win_data)
2350 {
2351         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2352         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2353         struct rk_fb_reg_data *regs;
2354 #ifdef H_USE_FENCE
2355         struct sync_fence *release_fence[RK_MAX_BUF_NUM];
2356         struct sync_fence *retire_fence;
2357         struct sync_pt *release_sync_pt[RK_MAX_BUF_NUM];
2358         struct sync_pt *retire_sync_pt;
2359         char fence_name[20];
2360 #endif
2361         int ret = 0, i, j = 0;
2362         int list_is_empty = 0;
2363
2364         regs = kzalloc(sizeof(struct rk_fb_reg_data), GFP_KERNEL);
2365         if (!regs) {
2366                 printk(KERN_INFO "could not allocate rk_fb_reg_data\n");
2367                 ret = -ENOMEM;
2368                 return ret;
2369         }
2370
2371 /*
2372         regs->post_cfg.xpos = win_data->post_cfg.xpos;
2373         regs->post_cfg.ypos = win_data->post_cfg.ypos;
2374         regs->post_cfg.xsize = win_data->post_cfg.xsize;
2375         regs->post_cfg.ysize = win_data->post_cfg.xsize;
2376 */
2377
2378         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
2379                 if (win_data->win_par[i].win_id < dev_drv->lcdc_win_num) {
2380                         if (rk_fb_set_win_buffer(info, &win_data->win_par[i],
2381                                                         &regs->reg_win_data[j]))
2382                                 return -ENOMEM;
2383                         if (regs->reg_win_data[j].area_num > 0) {
2384                                 regs->win_num++;
2385                                 regs->buf_num +=
2386                                     regs->reg_win_data[j].area_buf_num;
2387                         }
2388                         j++;
2389                 } else {
2390                         printk(KERN_INFO "error:win_id bigger than lcdc_win_num\n");
2391                         printk(KERN_INFO "i=%d,win_id=%d\n", i,
2392                                win_data->win_par[i].win_id);
2393                 }
2394         }
2395
2396         mutex_lock(&dev_drv->output_lock);
2397         if (!(dev_drv->suspend_flag == 0)) {
2398                 rk_fb_update_reg(dev_drv, regs);
2399                 kfree(regs);
2400                 printk(KERN_INFO "suspend_flag = 1\n");
2401                 goto err;
2402         }
2403
2404         dev_drv->timeline_max++;
2405 #ifdef H_USE_FENCE
2406         for (i = 0; i < RK_MAX_BUF_NUM; i++) {
2407                 if (i < regs->buf_num) {
2408                         sprintf(fence_name, "fence%d", i);
2409                         win_data->rel_fence_fd[i] = get_unused_fd();
2410                         if (win_data->rel_fence_fd[i] < 0) {
2411                                 printk(KERN_INFO "rel_fence_fd=%d\n",
2412                                        win_data->rel_fence_fd[i]);
2413                                 ret = -EFAULT;
2414                                 goto err;
2415                         }
2416                         release_sync_pt[i] =
2417                             sw_sync_pt_create(dev_drv->timeline,
2418                                               dev_drv->timeline_max);
2419                         release_fence[i] =
2420                             sync_fence_create(fence_name, release_sync_pt[i]);
2421                         sync_fence_install(release_fence[i],
2422                                            win_data->rel_fence_fd[i]);
2423                 } else {
2424                         win_data->rel_fence_fd[i] = -1;
2425                 }
2426         }
2427
2428         win_data->ret_fence_fd = get_unused_fd();
2429         if (win_data->ret_fence_fd < 0) {
2430                 printk("ret_fence_fd=%d\n", win_data->ret_fence_fd);
2431                 ret = -EFAULT;
2432                 goto err;
2433         }
2434         retire_sync_pt =
2435             sw_sync_pt_create(dev_drv->timeline, dev_drv->timeline_max);
2436         retire_fence = sync_fence_create("ret_fence", retire_sync_pt);
2437         sync_fence_install(retire_fence, win_data->ret_fence_fd);
2438 #else
2439         for (i = 0; i < RK_MAX_BUF_NUM; i++)
2440                 win_data->rel_fence_fd[i] = -1;
2441
2442         win_data->ret_fence_fd = -1;
2443 #endif
2444         if (dev_drv->wait_fs == 0) {
2445                 mutex_lock(&dev_drv->update_regs_list_lock);
2446                 list_add_tail(&regs->list, &dev_drv->update_regs_list);
2447                 mutex_unlock(&dev_drv->update_regs_list_lock);
2448                 queue_kthread_work(&dev_drv->update_regs_worker,
2449                                    &dev_drv->update_regs_work);
2450         } else {
2451                 mutex_lock(&dev_drv->update_regs_list_lock);
2452                 list_is_empty = list_empty(&dev_drv->update_regs_list) &&
2453                                         list_empty(&saved_list);
2454                 mutex_unlock(&dev_drv->update_regs_list_lock);
2455                 if (!list_is_empty) {
2456                         ret = wait_event_timeout(dev_drv->update_regs_wait,
2457                                 list_empty(&dev_drv->update_regs_list) && list_empty(&saved_list),
2458                                 msecs_to_jiffies(60));
2459                         if (ret > 0)
2460                                 rk_fb_update_reg(dev_drv, regs);
2461                         else
2462                                 printk("%s: wait update_regs_wait timeout\n", __func__);
2463                 } else if (ret == 0) {
2464                         rk_fb_update_reg(dev_drv, regs);
2465                 }
2466                 kfree(regs);
2467         }
2468
2469 err:
2470         mutex_unlock(&dev_drv->output_lock);
2471         return ret;
2472 }
2473
2474 #if 1
2475 static int cfgdone_distlist[10] = { 0 };
2476
2477 static int cfgdone_index;
2478 static int cfgdone_lasttime;
2479
2480 int rk_get_real_fps(int before)
2481 {
2482         struct timespec now;
2483         int dist_curr;
2484         int dist_total = 0;
2485         int dist_count = 0;
2486         int dist_first = 0;
2487
2488         int index = cfgdone_index;
2489         int i = 0, fps = 0;
2490         int total;
2491
2492         if (before > 100)
2493                 before = 100;
2494         if (before < 0)
2495                 before = 0;
2496
2497         getnstimeofday(&now);
2498         dist_curr = (now.tv_sec * 1000000 + now.tv_nsec / 1000) -
2499                         cfgdone_lasttime;
2500         total = dist_curr;
2501         /*
2502            printk("fps: ");
2503          */
2504         for (i = 0; i < 10; i++) {
2505                 if (--index < 0)
2506                         index = 9;
2507                 total += cfgdone_distlist[index];
2508                 if (i == 0)
2509                         dist_first = cfgdone_distlist[index];
2510                 if (total < (before * 1000)) {
2511                         /*
2512                            printk("[%d:%d] ", dist_count, cfgdone_distlist[index]);
2513                          */
2514                         dist_total += cfgdone_distlist[index];
2515                         dist_count++;
2516                 } else {
2517                         break;
2518                 }
2519         }
2520
2521         /*
2522            printk("total %d, count %d, curr %d, ", dist_total, dist_count, dist_curr);
2523          */
2524         dist_curr = (dist_curr > dist_first) ? dist_curr : dist_first;
2525         dist_total += dist_curr;
2526         dist_count++;
2527
2528         if (dist_total > 0)
2529                 fps = (1000000 * dist_count) / dist_total;
2530         else
2531                 fps = 60;
2532
2533         /*
2534            printk("curr2 %d, fps=%d\n", dist_curr, fps);
2535          */
2536         return fps;
2537 }
2538 EXPORT_SYMBOL(rk_get_real_fps);
2539
2540 #endif
2541 #ifdef CONFIG_ROCKCHIP_IOMMU
2542 #define ION_MAX 10
2543 static struct ion_handle *ion_hanle[ION_MAX];
2544 static struct ion_handle *ion_hwc[1];
2545 #endif
2546 static int rk_fb_ioctl(struct fb_info *info, unsigned int cmd,
2547                        unsigned long arg)
2548 {
2549         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
2550         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2551         struct rk_fb_par *extend_fb_par = NULL;
2552         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2553         struct fb_fix_screeninfo *fix = &info->fix;
2554         int fb_id = 0, extend_win_id = 0;
2555         struct fb_info *extend_info = NULL;
2556         struct rk_lcdc_driver *extend_dev_drv = NULL;
2557         struct rk_lcdc_win *extend_win = NULL;
2558         struct rk_lcdc_win *win;
2559         int enable;     /* enable fb:1 enable;0 disable */
2560         int ovl;        /* overlay:0 win1 on the top of win0;1,win0 on the top of win1 */
2561         int num_buf;    /* buffer_number */
2562         int ret;
2563         struct rk_fb_win_cfg_data win_data;
2564         unsigned int dsp_addr[4];
2565         int list_stat;
2566
2567         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
2568
2569         void __user *argp = (void __user *)arg;
2570         win = dev_drv->win[win_id];
2571         if (rk_fb->disp_mode == DUAL) {
2572                 fb_id = get_extend_fb_id(info);
2573                 extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
2574                 extend_fb_par = (struct rk_fb_par *)extend_info->par;
2575                 extend_dev_drv = extend_fb_par->lcdc_drv;
2576                 extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
2577                                                             extend_info->fix.id);
2578                 extend_win = extend_dev_drv->win[extend_win_id];
2579         }
2580
2581         switch (cmd) {
2582         case RK_FBIOSET_HWC_ADDR:
2583         {
2584                 u32 hwc_phy[1];
2585                 if (copy_from_user(hwc_phy, argp, 4))
2586                         return -EFAULT;
2587 #ifdef CONFIG_ROCKCHIP_IOMMU
2588                 if (!dev_drv->iommu_enabled) {
2589 #endif
2590                         fix->smem_start = hwc_phy[0];
2591 #ifdef CONFIG_ROCKCHIP_IOMMU
2592                 } else {
2593                         int usr_fd;
2594                         struct ion_handle *hdl;
2595                         ion_phys_addr_t phy_addr;
2596                         size_t len;
2597
2598                         usr_fd = hwc_phy[0];
2599                         if (!usr_fd) {
2600                                 fix->smem_start = 0;
2601                                 fix->mmio_start = 0;
2602                                 break;
2603                         }
2604
2605                         if (ion_hwc[0] != 0) {
2606                                 ion_free(rk_fb->ion_client, ion_hwc[0]);
2607                                 ion_hwc[0] = 0;
2608                         }
2609
2610                         hdl = ion_import_dma_buf(rk_fb->ion_client, usr_fd);
2611                         if (IS_ERR(hdl)) {
2612                                 dev_err(info->dev, "failed to get hwc ion handle:%ld\n",
2613                                         PTR_ERR(hdl));
2614                                 return -EFAULT;
2615                         }
2616
2617                         ret = ion_map_iommu(dev_drv->dev, rk_fb->ion_client, hdl,
2618                                                 (unsigned long *)&phy_addr,
2619                                                 (unsigned long *)&len);
2620                         if (ret < 0) {
2621                                 dev_err(info->dev, "ion map to get hwc phy addr failed");
2622                                 ion_free(rk_fb->ion_client, hdl);
2623                                 return -ENOMEM;
2624                         }
2625                         fix->smem_start = phy_addr;
2626                         ion_hwc[0] = hdl;
2627                 }
2628 #endif
2629                 break;
2630         }
2631         case RK_FBIOSET_YUV_ADDR:
2632                 {
2633                         u32 yuv_phy[2];
2634
2635                         if (copy_from_user(yuv_phy, argp, 8))
2636                                 return -EFAULT;
2637                         #ifdef CONFIG_ROCKCHIP_IOMMU
2638                         if (!dev_drv->iommu_enabled || !strcmp(info->fix.id, "fb0")) {
2639                         #endif
2640                                 fix->smem_start = yuv_phy[0];
2641                                 fix->mmio_start = yuv_phy[1];
2642                         #ifdef CONFIG_ROCKCHIP_IOMMU
2643                         } else {
2644                                 int usr_fd, offset, tmp;
2645                                 struct ion_handle *hdl;
2646                                 ion_phys_addr_t phy_addr;
2647                                 size_t len;
2648
2649                                 usr_fd = yuv_phy[0];
2650                                 offset = yuv_phy[1] - yuv_phy[0];
2651
2652                                 if (!usr_fd) {
2653                                         fix->smem_start = 0;
2654                                         fix->mmio_start = 0;
2655                                         break;
2656                                 }
2657
2658                                 if (ion_hanle[ION_MAX - 1] != 0) {
2659                                         /*ion_unmap_kernel(rk_fb->ion_client, ion_hanle[ION_MAX - 1]);*/
2660                                         /*ion_unmap_iommu(dev_drv->dev, rk_fb->ion_client, ion_hanle[ION_MAX - 1]);*/
2661                                         ion_free(rk_fb->ion_client, ion_hanle[ION_MAX - 1]);
2662                                         ion_hanle[ION_MAX - 1] = 0;
2663                                 }
2664
2665                                 hdl = ion_import_dma_buf(rk_fb->ion_client, usr_fd);
2666                                 if (IS_ERR(hdl)) {
2667                                         dev_err(info->dev, "failed to get ion handle:%ld\n",
2668                                                 PTR_ERR(hdl));
2669                                         return -EFAULT;
2670                                 }
2671
2672                                 ret = ion_map_iommu(dev_drv->dev, rk_fb->ion_client, hdl,
2673                                                         (unsigned long *)&phy_addr,
2674                                                         (unsigned long *)&len);
2675                                 if (ret < 0) {
2676                                         dev_err(info->dev, "ion map to get phy addr failed");
2677                                         ion_free(rk_fb->ion_client, hdl);
2678                                         return -ENOMEM;
2679                                 }
2680                                 fix->smem_start = phy_addr;
2681                                 fix->mmio_start = phy_addr + offset;
2682                                 fix->smem_len = len;
2683                                 /*info->screen_base = ion_map_kernel(rk_fb->ion_client, hdl);*/
2684
2685                                 ion_hanle[0] = hdl;
2686                                 for (tmp = ION_MAX - 1; tmp > 0; tmp--)
2687                                         ion_hanle[tmp] = ion_hanle[tmp - 1];
2688                                 ion_hanle[0] = 0;
2689                         }
2690                         #endif
2691                         break;
2692                 }
2693         case RK_FBIOSET_ENABLE:
2694                 if (copy_from_user(&enable, argp, sizeof(enable)))
2695                         return -EFAULT;
2696                 dev_drv->ops->open(dev_drv, win_id, enable);
2697                 break;
2698         case RK_FBIOGET_ENABLE:
2699                 enable = dev_drv->ops->get_win_state(dev_drv, win_id);
2700                 if (copy_to_user(argp, &enable, sizeof(enable)))
2701                         return -EFAULT;
2702                 break;
2703         case RK_FBIOSET_OVERLAY_STA:
2704                 if (copy_from_user(&ovl, argp, sizeof(ovl)))
2705                         return -EFAULT;
2706                 dev_drv->ops->ovl_mgr(dev_drv, ovl, 1);
2707                 break;
2708         case RK_FBIOGET_OVERLAY_STA:
2709                 ovl = dev_drv->ops->ovl_mgr(dev_drv, 0, 0);
2710                 if (copy_to_user(argp, &ovl, sizeof(ovl)))
2711                         return -EFAULT;
2712                 break;
2713         case RK_FBIOPUT_NUM_BUFFERS:
2714                 if (copy_from_user(&num_buf, argp, sizeof(num_buf)))
2715                         return -EFAULT;
2716                 dev_drv->num_buf = num_buf;
2717                 break;
2718         case RK_FBIOSET_VSYNC_ENABLE:
2719                 if (copy_from_user(&enable, argp, sizeof(enable)))
2720                         return -EFAULT;
2721                 dev_drv->vsync_info.active = enable;
2722                 break;
2723
2724         case RK_FBIOGET_DSP_ADDR:
2725                 dev_drv->ops->get_dsp_addr(dev_drv, dsp_addr);
2726                 if (copy_to_user(argp, &dsp_addr, sizeof(dsp_addr)))
2727                         return -EFAULT;
2728                 break;
2729         case RK_FBIOGET_LIST_STA:
2730                 list_stat = rk_fb_get_list_stat(dev_drv);
2731                 if (copy_to_user(argp, &list_stat, sizeof(list_stat)))
2732                         return -EFAULT;
2733
2734                 break;
2735         case RK_FBIOGET_IOMMU_STA:
2736                 if (copy_to_user(argp, &dev_drv->iommu_enabled,
2737                                  sizeof(dev_drv->iommu_enabled)))
2738                         return -EFAULT;
2739                 break;
2740 #if defined(CONFIG_ION_ROCKCHIP)
2741         case RK_FBIOSET_DMABUF_FD:
2742                 {
2743                         int usr_fd;
2744                         struct ion_handle *hdl;
2745                         ion_phys_addr_t phy_addr;
2746                         size_t len;
2747                         if (copy_from_user(&usr_fd, argp, sizeof(usr_fd)))
2748                                 return -EFAULT;
2749                         hdl = ion_import_dma_buf(rk_fb->ion_client, usr_fd);
2750                         ion_phys(rk_fb->ion_client, hdl, &phy_addr, &len);
2751                         fix->smem_start = phy_addr;
2752                         break;
2753                 }
2754         case RK_FBIOGET_DMABUF_FD:
2755                 {
2756                         int fd = -1;
2757
2758                         if (IS_ERR_OR_NULL(fb_par->ion_hdl)) {
2759                                 dev_err(info->dev,
2760                                         "get dma_buf fd failed,ion handle is err\n");
2761                                 return PTR_ERR(fb_par->ion_hdl);
2762                         }
2763                         fd = ion_share_dma_buf_fd(rk_fb->ion_client,
2764                                                   fb_par->ion_hdl);
2765                         if (fd < 0) {
2766                                 dev_err(info->dev,
2767                                         "ion_share_dma_buf_fd failed\n");
2768                                 return fd;
2769                         }
2770                         if (copy_to_user(argp, &fd, sizeof(fd)))
2771                                 return -EFAULT;
2772                         break;
2773                 }
2774 #endif
2775         case RK_FBIOSET_CLEAR_FB:
2776                 memset(fb_par->fb_virt_base, 0, fb_par->fb_size);
2777                 break;
2778         case RK_FBIOSET_CONFIG_DONE:
2779                 {
2780                         int curr = 0;
2781                         struct timespec now;
2782
2783                         getnstimeofday(&now);
2784                         curr = now.tv_sec * 1000000 + now.tv_nsec / 1000;
2785                         cfgdone_distlist[cfgdone_index++] =
2786                             curr - cfgdone_lasttime;
2787                         /*
2788                            printk("%d ", curr - cfgdone_lasttime);
2789                          */
2790                         cfgdone_lasttime = curr;
2791                         if (cfgdone_index >= 10)
2792                                 cfgdone_index = 0;
2793                 }
2794                 if (copy_from_user(&win_data,
2795                                    (struct rk_fb_win_cfg_data __user *)argp,
2796                                    sizeof(win_data))) {
2797                         ret = -EFAULT;
2798                         break;
2799                 };
2800
2801                 dev_drv->wait_fs = win_data.wait_fs;
2802                 rk_fb_set_win_config(info, &win_data);
2803
2804                 if (copy_to_user((struct rk_fb_win_cfg_data __user *)arg,
2805                                  &win_data, sizeof(win_data))) {
2806                         ret = -EFAULT;
2807                         break;
2808                 }
2809                 memset(&win_data, 0, sizeof(struct rk_fb_win_cfg_data));
2810                 break;
2811         default:
2812                 dev_drv->ops->ioctl(dev_drv, cmd, arg, win_id);
2813                 break;
2814         }
2815
2816         return 0;
2817 }
2818
2819 static int rk_fb_blank(int blank_mode, struct fb_info *info)
2820 {
2821         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2822         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2823         struct fb_fix_screeninfo *fix = &info->fix;
2824         int win_id;
2825 #if defined(CONFIG_RK_HDMI)
2826         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
2827 #endif
2828
2829         win_id = dev_drv->ops->fb_get_win_id(dev_drv, fix->id);
2830         if (win_id < 0)
2831                 return -ENODEV;
2832 #if defined(CONFIG_RK_HDMI)
2833         if ((rk_fb->disp_mode == ONE_DUAL) &&
2834             (hdmi_get_hotplug() == HDMI_HPD_ACTIVED)) {
2835                 printk(KERN_INFO "hdmi is connect , not blank lcdc\n");
2836         } else
2837 #endif
2838         {
2839                 dev_drv->ops->blank(dev_drv, win_id, blank_mode);
2840         }
2841         return 0;
2842 }
2843
2844 static int rk_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
2845 {
2846         if ((0 == var->xres_virtual) || (0 == var->yres_virtual) ||
2847             (0 == var->xres) || (0 == var->yres) || (var->xres < 16) ||
2848             ((16 != var->bits_per_pixel) &&
2849             (32 != var->bits_per_pixel) &&
2850             (24 != var->bits_per_pixel))) {
2851                 dev_err(info->dev, "%s check var fail 1:\n"
2852                         "xres_vir:%d>>yres_vir:%d\n"
2853                         "xres:%d>>yres:%d\n"
2854                         "bits_per_pixel:%d\n",
2855                         info->fix.id,
2856                         var->xres_virtual,
2857                         var->yres_virtual,
2858                         var->xres, var->yres, var->bits_per_pixel);
2859                 return -EINVAL;
2860         }
2861
2862         if (((var->xoffset + var->xres) > var->xres_virtual) ||
2863             ((var->yoffset + var->yres) > (var->yres_virtual))) {
2864                 dev_err(info->dev, "%s check_var fail 2:\n"
2865                         "xoffset:%d>>xres:%d>>xres_vir:%d\n"
2866                         "yoffset:%d>>yres:%d>>yres_vir:%d\n",
2867                         info->fix.id,
2868                         var->xoffset,
2869                         var->xres,
2870                         var->xres_virtual,
2871                         var->yoffset, var->yres, var->yres_virtual);
2872                 return -EINVAL;
2873         }
2874
2875         return 0;
2876 }
2877
2878 static ssize_t rk_fb_read(struct fb_info *info, char __user *buf,
2879                           size_t count, loff_t *ppos)
2880 {
2881         unsigned long p = *ppos;
2882         u8 *buffer, *dst;
2883         u8 __iomem *src;
2884         int c, cnt = 0, err = 0;
2885         unsigned long total_size;
2886         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2887         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2888         struct rk_lcdc_win *win = NULL;
2889         int win_id = 0;
2890
2891         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
2892         if (win_id < 0)
2893                 return -ENODEV;
2894         else
2895                 win = dev_drv->win[win_id];
2896
2897         /* only read the current frame buffer */
2898         if (win->format == RGB565) {
2899                 total_size = win->area[0].y_vir_stride * win->area[0].yact << 1;
2900         } else if (win->format == YUV420) {
2901                 total_size =
2902                     (win->area[0].y_vir_stride * win->area[0].yact * 6);
2903         } else {
2904                 total_size = win->area[0].y_vir_stride * win->area[0].yact << 2;
2905         }
2906         if (p >= total_size)
2907                 return 0;
2908
2909         if (count >= total_size)
2910                 count = total_size;
2911
2912         if (count + p > total_size)
2913                 count = total_size - p;
2914
2915         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
2916         if (!buffer)
2917                 return -ENOMEM;
2918
2919         src = (u8 __iomem *)(info->screen_base + p + win->area[0].y_offset);
2920
2921         while (count) {
2922                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
2923                 dst = buffer;
2924                 fb_memcpy_fromfb(dst, src, c);
2925                 dst += c;
2926                 src += c;
2927
2928                 if (copy_to_user(buf, buffer, c)) {
2929                         err = -EFAULT;
2930                         break;
2931                 }
2932                 *ppos += c;
2933                 buf += c;
2934                 cnt += c;
2935                 count -= c;
2936         }
2937
2938         kfree(buffer);
2939
2940         return (err) ? err : cnt;
2941 }
2942
2943 static ssize_t rk_fb_write(struct fb_info *info, const char __user *buf,
2944                            size_t count, loff_t *ppos)
2945 {
2946         unsigned long p = *ppos;
2947         u8 *buffer, *src;
2948         u8 __iomem *dst;
2949         int c, cnt = 0, err = 0;
2950         unsigned long total_size;
2951         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2952         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2953         struct rk_lcdc_win *win = NULL;
2954         int win_id = 0;
2955
2956         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
2957         if (win_id < 0)
2958                 return -ENODEV;
2959         else
2960                 win = dev_drv->win[win_id];
2961
2962         /* write the current frame buffer */
2963         if (win->format == RGB565)
2964                 total_size = win->area[0].xact * win->area[0].yact << 1;
2965         else
2966                 total_size = win->area[0].xact * win->area[0].yact << 2;
2967
2968         if (p > total_size)
2969                 return -EFBIG;
2970
2971         if (count > total_size) {
2972                 err = -EFBIG;
2973                 count = total_size;
2974         }
2975
2976         if (count + p > total_size) {
2977                 if (!err)
2978                         err = -ENOSPC;
2979
2980                 count = total_size - p;
2981         }
2982
2983         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
2984         if (!buffer)
2985                 return -ENOMEM;
2986
2987         dst = (u8 __iomem *)(info->screen_base + p + win->area[0].y_offset);
2988
2989         while (count) {
2990                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
2991                 src = buffer;
2992
2993                 if (copy_from_user(src, buf, c)) {
2994                         err = -EFAULT;
2995                         break;
2996                 }
2997
2998                 fb_memcpy_tofb(dst, src, c);
2999                 dst += c;
3000                 src += c;
3001                 *ppos += c;
3002                 buf += c;
3003                 cnt += c;
3004                 count -= c;
3005         }
3006
3007         kfree(buffer);
3008
3009         return (cnt) ? cnt : err;
3010 }
3011
3012 /*
3013  * function: update extend info acorrding to primary info that only used for dual display mode
3014  * @ext_info: the fb_info of extend screen
3015  * @info: the fb_info of primary screen
3016  * @update_buffer: whether to update extend info buffer, 0: no;1: yes
3017  */
3018 static int rk_fb_update_ext_info(struct fb_info *ext_info,
3019                                         struct fb_info *info, int update_buffer)
3020 {
3021         struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
3022         struct rk_fb_par *fb_par = NULL;
3023         struct rk_fb_par *ext_fb_par = NULL;
3024         struct rk_lcdc_driver *dev_drv = NULL;
3025         struct rk_lcdc_driver *ext_dev_drv = NULL;
3026         struct rk_lcdc_win *win = NULL;
3027         struct rk_lcdc_win *ext_win = NULL;
3028         int win_id = 0, ext_win_id = 0;
3029
3030         if (rk_fb->disp_mode != DUAL || info == ext_info)
3031                 return 0;
3032         if (unlikely(!info) || unlikely(!ext_info))
3033                 return -1;
3034
3035         fb_par = (struct rk_fb_par *)info->par;
3036         ext_fb_par = (struct rk_fb_par *)ext_info->par;
3037         dev_drv = fb_par->lcdc_drv;
3038         ext_dev_drv = ext_fb_par->lcdc_drv;
3039         if (unlikely(!dev_drv) || unlikely(!ext_dev_drv))
3040                 return -1;
3041
3042         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
3043         win = dev_drv->win[win_id];
3044         ext_win_id = ext_dev_drv->ops->fb_get_win_id(ext_dev_drv,
3045                                                      ext_info->fix.id);
3046         ext_win = ext_dev_drv->win[ext_win_id];
3047
3048         rk_fb_update_ext_win(ext_dev_drv, dev_drv, ext_win, win);
3049         if (update_buffer) {
3050                 rk_fb_set_ext_win_buffer(ext_win, win, ext_dev_drv->rotate_mode,
3051                                          ext_dev_drv->iommu_enabled);
3052
3053                 /* update extend info display address */
3054                 ext_info->fix.smem_start = ext_win->area[0].smem_start;
3055                 ext_info->fix.mmio_start = ext_win->area[0].cbr_start;
3056
3057                 if (ext_dev_drv->rotate_mode > X_Y_MIRROR)
3058                         rk_fb_rotate(ext_info, info);
3059         }
3060
3061         /* update extend info */
3062         ext_info->var.xres = ext_win->area[0].xact;
3063         ext_info->var.yres = ext_win->area[0].yact;
3064         ext_info->var.xres_virtual = ext_win->area[0].xvir;
3065         ext_info->var.yres_virtual = ext_win->area[0].yvir;
3066
3067         /* config same data format */
3068         ext_info->var.nonstd &= 0xffffff00;
3069         ext_info->var.nonstd |= (info->var.nonstd & 0xff);
3070
3071         ext_info->var.nonstd &= 0xff;
3072         ext_info->var.nonstd |=
3073                 (ext_win->area[0].xpos << 8) + (ext_win->area[0].ypos << 20);
3074
3075         ext_info->var.grayscale &= 0xff;
3076         ext_info->var.grayscale |=
3077                 (ext_win->area[0].xsize << 8) + (ext_win->area[0].ysize << 20);
3078
3079         return 0;
3080 }
3081
3082 static int rk_fb_set_par(struct fb_info *info)
3083 {
3084         struct fb_var_screeninfo *var = &info->var;
3085         struct fb_fix_screeninfo *fix = &info->fix;
3086         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
3087         struct rk_fb_par *extend_fb_par = NULL;
3088         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3089         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
3090         int fb_id, extend_win_id = 0;
3091         struct fb_info *extend_info = NULL;
3092         struct rk_lcdc_driver *extend_dev_drv = NULL;
3093         struct rk_lcdc_win *extend_win = NULL;
3094         struct rk_lcdc_win *win = NULL;
3095         struct rk_screen *screen = dev_drv->cur_screen;
3096         int win_id = 0;
3097         u32 cblen = 0, crlen = 0;
3098         u16 xsize = 0, ysize = 0;       /* winx display window height/width --->LCDC_WINx_DSP_INFO */
3099         u32 xoffset = var->xoffset;     /* offset from virtual to visible */
3100         u32 yoffset = var->yoffset;
3101         u16 xpos = (var->nonstd >> 8) & 0xfff;  /*visiable pos in panel */
3102         u16 ypos = (var->nonstd >> 20) & 0xfff;
3103         u32 xvir = var->xres_virtual;
3104         u32 yvir = var->yres_virtual;
3105         u8 data_format = var->nonstd & 0xff;
3106         u8 fb_data_fmt;
3107         u8 pixel_width;
3108         u32 vir_width_bit;
3109         u32 stride, uv_stride;
3110         u32 stride_32bit_1;
3111         u32 stride_32bit_2;
3112         u16 uv_x_off, uv_y_off, uv_y_act;
3113         u8 is_pic_yuv = 0;
3114
3115         var->pixclock = dev_drv->pixclock;
3116         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
3117         if (win_id < 0)
3118                 return -ENODEV;
3119         else
3120                 win = dev_drv->win[win_id];
3121
3122         if (rk_fb->disp_mode == DUAL) {
3123                 fb_id = get_extend_fb_id(info);
3124                 extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
3125                 extend_fb_par = (struct rk_fb_par *)extend_info->par;
3126                 extend_dev_drv = extend_fb_par->lcdc_drv;
3127                 extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
3128                                                             extend_info->fix.id);
3129                 extend_win = extend_dev_drv->win[extend_win_id];
3130         }
3131
3132         /* if the application has specific the horizontal and vertical display size */
3133         if (var->grayscale >> 8) {
3134                 xsize = (var->grayscale >> 8) & 0xfff;
3135                 ysize = (var->grayscale >> 20) & 0xfff;
3136                 if (xsize > screen->mode.xres)
3137                         xsize = screen->mode.xres;
3138                 if (ysize > screen->mode.yres)
3139                         ysize = screen->mode.yres;
3140         } else {                /*ohterwise  full  screen display */
3141                 xsize = screen->mode.xres;
3142                 ysize = screen->mode.yres;
3143         }
3144
3145         fb_data_fmt = rk_fb_data_fmt(data_format, var->bits_per_pixel);
3146         pixel_width = rk_fb_pixel_width(fb_data_fmt);
3147         vir_width_bit = pixel_width * xvir;
3148         /* pixel_width = byte_num * 8 */
3149         stride_32bit_1 = ALIGN_N_TIMES(vir_width_bit, 32) / 8;
3150         stride_32bit_2 = ALIGN_N_TIMES(vir_width_bit * 2, 32) / 8;
3151
3152         switch (fb_data_fmt) {
3153         case YUV422:
3154         case YUV422_A:
3155                 is_pic_yuv = 1;
3156                 stride = stride_32bit_1;
3157                 uv_stride = stride_32bit_1 >> 1;
3158                 uv_x_off = xoffset >> 1;
3159                 uv_y_off = yoffset;
3160                 fix->line_length = stride;
3161                 cblen = crlen = (xvir * yvir) >> 1;
3162                 uv_y_act = win->area[0].yact >> 1;
3163                 break;
3164         case YUV420:            /* 420sp */
3165         case YUV420_A:
3166                 is_pic_yuv = 1;
3167                 stride = stride_32bit_1;
3168                 uv_stride = stride_32bit_1;
3169                 uv_x_off = xoffset;
3170                 uv_y_off = yoffset >> 1;
3171                 fix->line_length = stride;
3172                 cblen = crlen = (xvir * yvir) >> 2;
3173                 uv_y_act = win->area[0].yact >> 1;
3174                 break;
3175         case YUV444:
3176         case YUV444_A:
3177                 is_pic_yuv = 1;
3178                 stride = stride_32bit_1;
3179                 uv_stride = stride_32bit_2;
3180                 uv_x_off = xoffset * 2;
3181                 uv_y_off = yoffset;
3182                 fix->line_length = stride << 2;
3183                 cblen = crlen = (xvir * yvir);
3184                 uv_y_act = win->area[0].yact;
3185                 break;
3186         default:
3187                 stride = stride_32bit_1;        /* default rgb */
3188                 fix->line_length = stride;
3189                 break;
3190         }
3191
3192         /* x y mirror ,jump line */
3193         if (screen->y_mirror == 1) {
3194                 if (screen->interlace == 1) {
3195                         win->area[0].y_offset = yoffset * stride * 2 +
3196                             ((win->area[0].yact - 1) * 2 + 1) * stride +
3197                             xoffset * pixel_width / 8;
3198                 } else {
3199                         win->area[0].y_offset = yoffset * stride +
3200                             (win->area[0].yact - 1) * stride +
3201                             xoffset * pixel_width / 8;
3202                 }
3203         } else {
3204                 if (screen->interlace == 1) {
3205                         win->area[0].y_offset =
3206                             yoffset * stride * 2 + xoffset * pixel_width / 8;
3207                 } else {
3208                         win->area[0].y_offset =
3209                             yoffset * stride + xoffset * pixel_width / 8;
3210                 }
3211         }
3212         if (is_pic_yuv == 1) {
3213                 if (screen->y_mirror == 1) {
3214                         if (screen->interlace == 1) {
3215                                 win->area[0].c_offset =
3216                                     uv_y_off * uv_stride * 2 +
3217                                     ((uv_y_act - 1) * 2 + 1) * uv_stride +
3218                                     uv_x_off * pixel_width / 8;
3219                         } else {
3220                                 win->area[0].c_offset = uv_y_off * uv_stride +
3221                                     (uv_y_act - 1) * uv_stride +
3222                                     uv_x_off * pixel_width / 8;
3223                         }
3224                 } else {
3225                         if (screen->interlace == 1) {
3226                                 win->area[0].c_offset =
3227                                     uv_y_off * uv_stride * 2 +
3228                                     uv_x_off * pixel_width / 8;
3229                         } else {
3230                                 win->area[0].c_offset =
3231                                     uv_y_off * uv_stride +
3232                                     uv_x_off * pixel_width / 8;
3233                         }
3234                 }
3235         }
3236
3237         win->format = fb_data_fmt;
3238         win->area[0].y_vir_stride = stride >> 2;
3239         win->area[0].uv_vir_stride = uv_stride >> 2;
3240         win->area[0].xpos = xpos;
3241         win->area[0].ypos = ypos;
3242         win->area[0].xsize = xsize;
3243         win->area[0].ysize = ysize;
3244         win->area[0].xact = var->xres;  /* winx active window height,is a wint of vir */
3245         win->area[0].yact = var->yres;
3246         win->area[0].xvir = var->xres_virtual;  /* virtual resolution  stride --->LCDC_WINx_VIR */
3247         win->area[0].yvir = var->yres_virtual;
3248
3249         win->area_num = 1;
3250         win->alpha_mode = 4;    /* AB_SRC_OVER; */
3251         win->alpha_en = ((win->format == ARGB888) ||
3252                          (win->format == ABGR888)) ? 1 : 0;
3253         win->g_alpha_val = 0;
3254
3255         if (rk_fb->disp_mode == DUAL) {
3256                 if (extend_win->state && hdmi_switch_complete) {
3257                         if (info != extend_info) {
3258                                 rk_fb_update_ext_win(extend_dev_drv, dev_drv,
3259                                                      extend_win, win);
3260                                 extend_dev_drv->ops->set_par(extend_dev_drv,
3261                                                              extend_win_id);
3262                         }
3263                 }
3264         }
3265         dev_drv->ops->set_par(dev_drv, win_id);
3266
3267         return 0;
3268 }
3269
3270 static inline unsigned int chan_to_field(unsigned int chan,
3271                                          struct fb_bitfield *bf)
3272 {
3273         chan &= 0xffff;
3274         chan >>= 16 - bf->length;
3275         return chan << bf->offset;
3276 }
3277
3278 static int fb_setcolreg(unsigned regno,
3279                         unsigned red, unsigned green, unsigned blue,
3280                         unsigned transp, struct fb_info *info)
3281 {
3282         unsigned int val;
3283
3284         switch (info->fix.visual) {
3285         case FB_VISUAL_TRUECOLOR:
3286                 /* true-colour, use pseudo-palette */
3287                 if (regno < 16) {
3288                         u32 *pal = info->pseudo_palette;
3289                         val = chan_to_field(red, &info->var.red);
3290                         val |= chan_to_field(green, &info->var.green);
3291                         val |= chan_to_field(blue, &info->var.blue);
3292                         pal[regno] = val;
3293                 }
3294                 break;
3295         default:
3296                 return -1;      /* unknown type */
3297         }
3298
3299         return 0;
3300 }
3301
3302 static int rk_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
3303 {
3304         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3305         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
3306         struct ion_handle *handle = fb_par->ion_hdl;
3307         struct dma_buf *dma_buf = NULL;
3308
3309         if (IS_ERR_OR_NULL(handle)) {
3310                 dev_err(info->dev, "failed to get ion handle:%ld\n",
3311                         PTR_ERR(handle));
3312                 return -ENOMEM;
3313         }
3314         dma_buf = ion_share_dma_buf(rk_fb->ion_client, handle);
3315         if (IS_ERR_OR_NULL(dma_buf)) {
3316                 printk("get ion share dma buf failed\n");
3317                 return -ENOMEM;
3318         }
3319
3320         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
3321
3322         return dma_buf_mmap(dma_buf, vma, 0);
3323 }
3324
3325 static struct fb_ops fb_ops = {
3326         .owner = THIS_MODULE,
3327         .fb_open = rk_fb_open,
3328         .fb_release = rk_fb_close,
3329         .fb_check_var = rk_fb_check_var,
3330         .fb_set_par = rk_fb_set_par,
3331         .fb_blank = rk_fb_blank,
3332         .fb_ioctl = rk_fb_ioctl,
3333         .fb_pan_display = rk_fb_pan_display,
3334         .fb_read = rk_fb_read,
3335         .fb_write = rk_fb_write,
3336         .fb_setcolreg = fb_setcolreg,
3337         .fb_fillrect = cfb_fillrect,
3338         .fb_copyarea = cfb_copyarea,
3339         .fb_imageblit = cfb_imageblit,
3340 };
3341
3342 static struct fb_var_screeninfo def_var = {
3343 #if defined(CONFIG_LOGO_LINUX_BMP)
3344         .red = {16, 8, 0},
3345         .green = {8, 8, 0},
3346         .blue = {0, 8, 0},
3347         .transp = {0, 0, 0},
3348         .nonstd = HAL_PIXEL_FORMAT_BGRA_8888,
3349 #else
3350         .red = {11, 5, 0},
3351         .green = {5, 6, 0},
3352         .blue = {0, 5, 0},
3353         .transp = {0, 0, 0},
3354         .nonstd = HAL_PIXEL_FORMAT_RGB_565,     /* (ypos<<20+xpos<<8+format) format */
3355 #endif
3356         .grayscale = 0,         /* (ysize<<20+xsize<<8) */
3357         .activate = FB_ACTIVATE_NOW,
3358         .accel_flags = 0,
3359         .vmode = FB_VMODE_NONINTERLACED,
3360 };
3361
3362 static struct fb_fix_screeninfo def_fix = {
3363         .type = FB_TYPE_PACKED_PIXELS,
3364         .type_aux = 0,
3365         .xpanstep = 1,
3366         .ypanstep = 1,
3367         .ywrapstep = 0,
3368         .accel = FB_ACCEL_NONE,
3369         .visual = FB_VISUAL_TRUECOLOR,
3370
3371 };
3372
3373 static int rk_fb_wait_for_vsync_thread(void *data)
3374 {
3375         struct rk_lcdc_driver *dev_drv = data;
3376         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3377         struct fb_info *fbi = rk_fb->fb[0];
3378
3379         while (!kthread_should_stop()) {
3380                 ktime_t timestamp = dev_drv->vsync_info.timestamp;
3381                 int ret = wait_event_interruptible(dev_drv->vsync_info.wait,
3382                                 !ktime_equal(timestamp, dev_drv->vsync_info.timestamp) &&
3383                                 (dev_drv->vsync_info.active || dev_drv->vsync_info.irq_stop));
3384
3385                 if (!ret)
3386                         sysfs_notify(&fbi->dev->kobj, NULL, "vsync");
3387         }
3388
3389         return 0;
3390 }
3391
3392 static ssize_t rk_fb_vsync_show(struct device *dev,
3393                                 struct device_attribute *attr, char *buf)
3394 {
3395         struct fb_info *fbi = dev_get_drvdata(dev);
3396         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
3397         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3398         return scnprintf(buf, PAGE_SIZE, "%llu\n",
3399                          ktime_to_ns(dev_drv->vsync_info.timestamp));
3400 }
3401
3402 static DEVICE_ATTR(vsync, S_IRUGO, rk_fb_vsync_show, NULL);
3403
3404 /*
3405  * this two function is for other module that in the kernel which
3406  * need show image directly through fb
3407  * fb_id:we have 4 fb here,default we use fb0 for ui display
3408  */
3409 struct fb_info *rk_get_fb(int fb_id)
3410 {
3411         struct rk_fb *inf = platform_get_drvdata(fb_pdev);
3412         struct fb_info *fb = inf->fb[fb_id];
3413         return fb;
3414 }
3415 EXPORT_SYMBOL(rk_get_fb);
3416
3417 void rk_direct_fb_show(struct fb_info *fbi)
3418 {
3419         rk_fb_set_par(fbi);
3420         rk_fb_pan_display(&fbi->var, fbi);
3421 }
3422 EXPORT_SYMBOL(rk_direct_fb_show);
3423
3424 int rk_fb_dpi_open(bool open)
3425 {
3426         struct rk_lcdc_driver *dev_drv = NULL;
3427         dev_drv = rk_get_prmry_lcdc_drv();
3428
3429         if (dev_drv->ops->dpi_open)
3430                 dev_drv->ops->dpi_open(dev_drv, open);
3431         return 0;
3432 }
3433
3434 int rk_fb_dpi_win_sel(int win_id)
3435 {
3436         struct rk_lcdc_driver *dev_drv = NULL;
3437         dev_drv = rk_get_prmry_lcdc_drv();
3438
3439         if (dev_drv->ops->dpi_win_sel)
3440                 dev_drv->ops->dpi_win_sel(dev_drv, win_id);
3441         return 0;
3442 }
3443
3444 int rk_fb_dpi_status(void)
3445 {
3446         int ret = 0;
3447         struct rk_lcdc_driver *dev_drv = NULL;
3448
3449         dev_drv = rk_get_prmry_lcdc_drv();
3450         if (dev_drv->ops->dpi_status)
3451                 ret = dev_drv->ops->dpi_status(dev_drv);
3452
3453         return ret;
3454 }
3455
3456 /*
3457  * function: this function will be called by display device, enable/disable lcdc
3458  * @screen: screen timing to be set to lcdc
3459  * @enable: 0 disable lcdc; 1 enable change lcdc timing; 2 just enable dclk
3460  * @lcdc_id: the lcdc id the display device attached ,0 or 1
3461  */
3462 int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
3463 {
3464         struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
3465         struct fb_info *info = NULL;
3466         struct fb_info *pmy_info = NULL;
3467         struct rk_fb_par *fb_par = NULL;
3468         struct rk_fb_par *pmy_fb_par = NULL;
3469         struct rk_lcdc_driver *dev_drv = NULL;
3470         char name[6] = {0};
3471         int i, win_id, load_screen = 0;
3472
3473         if (unlikely(!rk_fb) || unlikely(!screen))
3474                 return -ENODEV;
3475
3476         hdmi_switch_complete = 0;
3477         /* get lcdc driver */
3478         sprintf(name, "lcdc%d", lcdc_id);
3479         if (rk_fb->disp_mode != DUAL)
3480                 dev_drv = rk_fb->lcdc_dev_drv[0];
3481         else
3482                 dev_drv = rk_get_lcdc_drv(name);
3483
3484         if (dev_drv == NULL) {
3485                 printk(KERN_ERR "%s driver not found!", name);
3486                 return -ENODEV;
3487         }
3488         if (screen->type == SCREEN_HDMI)
3489                 printk("hdmi %s lcdc%d\n", enable ? "connect to" : "remove from",
3490                         dev_drv->id);
3491         else if (screen->type == SCREEN_TVOUT ||
3492                      screen->type == SCREEN_TVOUT_TEST )
3493                 printk("cvbs %s lcdc%d\n", enable ? "connect to" : "remove from",
3494                         dev_drv->id);
3495         if (enable == 2 /*&& dev_drv->enable*/)
3496                 return 0;
3497
3498         if (rk_fb->disp_mode == ONE_DUAL) {
3499                 if (dev_drv->ops->dsp_black)
3500                         dev_drv->ops->dsp_black(dev_drv, 1);
3501                 if (dev_drv->ops->set_screen_scaler)
3502                         dev_drv->ops->set_screen_scaler(dev_drv, dev_drv->screen0, 0);
3503         }
3504
3505         if (!enable) {
3506                 /* if screen type is different, we do not disable lcdc. */
3507                 if (dev_drv->cur_screen->type != screen->type)
3508                         return 0;
3509
3510                 /* if used one lcdc to dual disp, no need to close win */
3511                 if (rk_fb->disp_mode == ONE_DUAL) {
3512                         dev_drv->cur_screen = dev_drv->screen0;
3513                         dev_drv->ops->load_screen(dev_drv, 1);
3514
3515                         /* force modify dsp size */
3516                         info = rk_fb->fb[dev_drv->fb_index_base];
3517                         info->var.grayscale &= 0xff;
3518                         info->var.grayscale |=
3519                                 (dev_drv->cur_screen->mode.xres << 8) +
3520                                 (dev_drv->cur_screen->mode.yres << 20);
3521                         info->fbops->fb_set_par(info);
3522                         info->fbops->fb_pan_display(&info->var, info);
3523
3524                         if (dev_drv->ops->dsp_black)
3525                                 dev_drv->ops->dsp_black(dev_drv, 0);
3526                 } else if (rk_fb->num_lcdc > 1) {
3527                         /* If there is more than one lcdc device, we disable
3528                            the layer which attached to this device */
3529                         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3530                                 if (dev_drv->win[i] && dev_drv->win[i]->state)
3531                                         dev_drv->ops->open(dev_drv, i, 0);
3532                         }
3533                 }
3534
3535                 hdmi_switch_complete = 0;
3536                 return 0;
3537         } else {
3538                 if (dev_drv->screen1)
3539                         dev_drv->cur_screen = dev_drv->screen1;
3540                 memcpy(dev_drv->cur_screen, screen, sizeof(struct rk_screen));
3541                 dev_drv->cur_screen->xsize = dev_drv->cur_screen->mode.xres;
3542                 dev_drv->cur_screen->ysize = dev_drv->cur_screen->mode.yres;
3543                 dev_drv->cur_screen->x_mirror = dev_drv->rotate_mode & X_MIRROR;
3544                 dev_drv->cur_screen->y_mirror = dev_drv->rotate_mode & Y_MIRROR;
3545         }
3546         if (!dev_drv->uboot_logo) {
3547                 for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3548                         info = rk_fb->fb[dev_drv->fb_index_base + i];
3549                         fb_par = (struct rk_fb_par *)info->par;
3550                         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
3551                         if (dev_drv->win[win_id]) {
3552                                 if (rk_fb->disp_mode == DUAL) {
3553                                         pmy_info = rk_fb->fb[i];
3554                                         if (pmy_info != info) {
3555                                                 pmy_fb_par =
3556                                                         (struct rk_fb_par *)pmy_info->par;
3557                                                 fb_par->state = pmy_fb_par->state;
3558                                         }
3559                                 }
3560                                 if (fb_par->state) {
3561                                         if (!dev_drv->win[win_id]->state)
3562                                                 dev_drv->ops->open(dev_drv, win_id, 1);
3563                                         if (!load_screen) {
3564                                                 dev_drv->ops->load_screen(dev_drv, 1);
3565                                                 load_screen = 1;
3566                                         }
3567                                         info->var.activate |= FB_ACTIVATE_FORCE;
3568                                         if (rk_fb->disp_mode == DUAL) {
3569                                                 rk_fb_update_ext_info(info, pmy_info, 1);
3570                                         } else if (rk_fb->disp_mode == ONE_DUAL) {
3571                                                 info->var.grayscale &= 0xff;
3572                                                 info->var.grayscale |=
3573                                                         (dev_drv->cur_screen->xsize << 8) +
3574                                                         (dev_drv->cur_screen->ysize << 20);
3575                                         }
3576                                         info->fbops->fb_set_par(info);
3577                                         info->fbops->fb_pan_display(&info->var, info);
3578                                 }
3579                         }
3580                 }
3581         }else {
3582                 dev_drv->uboot_logo = 0;
3583         }
3584         hdmi_switch_complete = 1;
3585         if (rk_fb->disp_mode == ONE_DUAL) {
3586                 if (dev_drv->ops->set_screen_scaler)
3587                         dev_drv->ops->set_screen_scaler(dev_drv, dev_drv->screen0, 1);
3588                 if (dev_drv->ops->dsp_black)
3589                         dev_drv->ops->dsp_black(dev_drv, 0);
3590         }
3591         return 0;
3592 }
3593
3594 /*
3595  * function:this function current only called by hdmi for
3596  *      scale the display
3597  * scale_x: scale rate of x resolution
3598  * scale_y: scale rate of y resolution
3599  * lcdc_id: the lcdc id the hdmi attached ,0 or 1
3600  */
3601 int rk_fb_disp_scale(u8 scale_x, u8 scale_y, u8 lcdc_id)
3602 {
3603         struct rk_fb *inf = platform_get_drvdata(fb_pdev);
3604         struct fb_info *info = NULL;
3605         struct fb_info *pmy_info = NULL;
3606         struct fb_var_screeninfo *var = NULL;
3607         struct rk_lcdc_driver *dev_drv = NULL;
3608         u16 screen_x, screen_y;
3609         u16 xpos, ypos;
3610         char name[6];
3611         struct rk_screen primary_screen;
3612         rk_fb_get_prmry_screen(&primary_screen);
3613         if (primary_screen.type == SCREEN_HDMI) {
3614                 return 0;
3615         }
3616
3617         sprintf(name, "lcdc%d", lcdc_id);
3618
3619         if (inf->disp_mode == DUAL) {
3620                 dev_drv = rk_get_lcdc_drv(name);
3621                 if (dev_drv == NULL) {
3622                         printk(KERN_ERR "%s driver not found!", name);
3623                         return -ENODEV;
3624                 }
3625         } else {
3626                 dev_drv = inf->lcdc_dev_drv[0];
3627         }
3628
3629         if (inf->num_lcdc == 1) {
3630                 info = inf->fb[0];
3631         } else if (inf->num_lcdc == 2) {
3632                 info = inf->fb[dev_drv->lcdc_win_num];
3633                 pmy_info = inf->fb[0];
3634         }
3635
3636         var = &info->var;
3637         screen_x = dev_drv->cur_screen->mode.xres;
3638         screen_y = dev_drv->cur_screen->mode.yres;
3639
3640         if (inf->disp_mode != DUAL && dev_drv->screen1) {
3641                 dev_drv->cur_screen->xpos =
3642                     (screen_x - screen_x * scale_x / 100) >> 1;
3643                 dev_drv->cur_screen->ypos =
3644                     (screen_y - screen_y * scale_y / 100) >> 1;
3645                 dev_drv->cur_screen->xsize = screen_x * scale_x / 100;
3646                 dev_drv->cur_screen->ysize = screen_y * scale_y / 100;
3647         } else {
3648                 xpos = (screen_x - screen_x * scale_x / 100) >> 1;
3649                 ypos = (screen_y - screen_y * scale_y / 100) >> 1;
3650                 dev_drv->cur_screen->xsize = screen_x * scale_x / 100;
3651                 dev_drv->cur_screen->ysize = screen_y * scale_y / 100;
3652                 if (inf->disp_mode == DUAL) {
3653                         rk_fb_update_ext_info(info, pmy_info, 0);
3654                 } else {
3655                         var->nonstd &= 0xff;
3656                         var->nonstd |= (xpos << 8) + (ypos << 20);
3657                         var->grayscale &= 0xff;
3658                         var->grayscale |=
3659                                 (dev_drv->cur_screen->xsize << 8) +
3660                                 (dev_drv->cur_screen->ysize << 20);
3661                 }
3662         }
3663
3664         info->fbops->fb_set_par(info);
3665         /* info->fbops->fb_ioctl(info, RK_FBIOSET_CONFIG_DONE, 0); */
3666         dev_drv->ops->cfg_done(dev_drv);
3667         return 0;
3668 }
3669
3670 #if defined(CONFIG_ION_ROCKCHIP)
3671 static int rk_fb_alloc_buffer_by_ion(struct fb_info *fbi,
3672                                      struct rk_lcdc_win *win,
3673                                      unsigned long fb_mem_size)
3674 {
3675         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3676         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
3677         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3678         struct ion_handle *handle;
3679         ion_phys_addr_t phy_addr;
3680         size_t len;
3681         int ret = 0;
3682
3683         if (dev_drv->iommu_enabled)
3684                 handle = ion_alloc(rk_fb->ion_client, (size_t) fb_mem_size, 0,
3685                                    ION_HEAP(ION_VMALLOC_HEAP_ID), 0);
3686         else
3687                 handle = ion_alloc(rk_fb->ion_client, (size_t) fb_mem_size, 0,
3688                                    ION_HEAP(ION_CMA_HEAP_ID), 0);
3689         if (IS_ERR(handle)) {
3690                 dev_err(fbi->device, "failed to ion_alloc:%ld\n",
3691                         PTR_ERR(handle));
3692                 return -ENOMEM;
3693         }
3694
3695         fb_par->ion_hdl = handle;
3696         win->area[0].dma_buf = ion_share_dma_buf(rk_fb->ion_client, handle);
3697         if (IS_ERR_OR_NULL(win->area[0].dma_buf)) {
3698                 printk("ion_share_dma_buf() failed\n");
3699                 goto err_share_dma_buf;
3700         }
3701         win->area[0].ion_hdl = handle;
3702         if (dev_drv->prop == PRMRY)
3703                 fbi->screen_base = ion_map_kernel(rk_fb->ion_client, handle);
3704 #ifdef CONFIG_ROCKCHIP_IOMMU
3705         if (dev_drv->iommu_enabled && dev_drv->mmu_dev)
3706                 ret = ion_map_iommu(dev_drv->dev, rk_fb->ion_client, handle,
3707                                         (unsigned long *)&phy_addr,
3708                                         (unsigned long *)&len);
3709         else
3710                 ret = ion_phys(rk_fb->ion_client, handle, &phy_addr, &len);
3711 #else
3712         ret = ion_phys(rk_fb->ion_client, handle, &phy_addr, &len);
3713 #endif
3714         if (ret < 0) {
3715                 dev_err(fbi->dev, "ion map to get phy addr failed\n");
3716                 goto err_share_dma_buf;
3717         }
3718         fbi->fix.smem_start = phy_addr;
3719         fbi->fix.smem_len = len;
3720         printk(KERN_INFO "alloc_buffer:ion_phy_addr=0x%lx\n", phy_addr);
3721         return 0;
3722
3723 err_share_dma_buf:
3724         ion_free(rk_fb->ion_client, handle);
3725         return -ENOMEM;
3726 }
3727 #endif
3728
3729 static int rk_fb_alloc_buffer(struct fb_info *fbi, int fb_id)
3730 {
3731         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3732         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
3733         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3734         struct rk_lcdc_win *win = NULL;
3735         int win_id;
3736         int ret = 0;
3737         unsigned long fb_mem_size;
3738 #if !defined(CONFIG_ION_ROCKCHIP)
3739         dma_addr_t fb_mem_phys;
3740         void *fb_mem_virt;
3741 #endif
3742
3743         win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
3744         if (win_id < 0)
3745                 return -ENODEV;
3746         else
3747                 win = dev_drv->win[win_id];
3748
3749         if (!strcmp(fbi->fix.id, "fb0")) {
3750                 fb_mem_size = get_fb_size();
3751 #if defined(CONFIG_ION_ROCKCHIP)
3752                 if (rk_fb_alloc_buffer_by_ion(fbi, win, fb_mem_size) < 0)
3753                         return -ENOMEM;
3754 #else
3755                 fb_mem_virt = dma_alloc_writecombine(fbi->dev, fb_mem_size,
3756                                                      &fb_mem_phys, GFP_KERNEL);
3757                 if (!fb_mem_virt) {
3758                         pr_err("%s: Failed to allocate framebuffer\n",
3759                                __func__);
3760                         return -ENOMEM;
3761                 }
3762                 fbi->fix.smem_len = fb_mem_size;
3763                 fbi->fix.smem_start = fb_mem_phys;
3764                 fbi->screen_base = fb_mem_virt;
3765 #endif
3766                 memset(fbi->screen_base, 0, fbi->fix.smem_len);
3767                 printk(KERN_INFO "fb%d:phy:%lx>>vir:%p>>len:0x%x\n", fb_id,
3768                        fbi->fix.smem_start, fbi->screen_base,
3769                        fbi->fix.smem_len);
3770         } else {
3771                 if (dev_drv->rotate_mode > X_Y_MIRROR) {
3772                         fb_mem_size = get_rotate_fb_size();
3773 #if defined(CONFIG_ION_ROCKCHIP)
3774                         if (rk_fb_alloc_buffer_by_ion(fbi, win, fb_mem_size) < 0)
3775                                 return -ENOMEM;
3776 #else
3777                         fb_mem_virt =
3778                                 dma_alloc_writecombine(fbi->dev,
3779                                                        fb_mem_size,
3780                                                        &fb_mem_phys,
3781                                                        GFP_KERNEL);
3782                         if (!fb_mem_virt) {
3783                                 pr_err("%s: Failed to allocate framebuffer\n",
3784                                         __func__);
3785                                 return -ENOMEM;
3786                         }
3787                         fbi->fix.smem_len = fb_mem_size;
3788                         fbi->fix.smem_start = fb_mem_phys;
3789                         fbi->screen_base = fb_mem_virt;
3790 #endif
3791                 } else {
3792                         fbi->fix.smem_start = rk_fb->fb[0]->fix.smem_start;
3793                         fbi->fix.smem_len = rk_fb->fb[0]->fix.smem_len;
3794                         fbi->screen_base = rk_fb->fb[0]->screen_base;
3795                 }
3796
3797                 printk(KERN_INFO "fb%d:phy:%lx>>vir:%p>>len:0x%x\n", fb_id,
3798                        fbi->fix.smem_start, fbi->screen_base,
3799                        fbi->fix.smem_len);
3800         }
3801
3802         fbi->screen_size = fbi->fix.smem_len;
3803         fb_par->fb_phy_base = fbi->fix.smem_start;
3804         fb_par->fb_virt_base = fbi->screen_base;
3805         fb_par->fb_size = fbi->fix.smem_len;
3806
3807         return ret;
3808 }
3809
3810 #if 0
3811 static int rk_release_fb_buffer(struct fb_info *fbi)
3812 {
3813         /* buffer for fb1 and fb3 are alloc by android */
3814         if (!strcmp(fbi->fix.id, "fb1") || !strcmp(fbi->fix.id, "fb3"))
3815                 return 0;
3816         iounmap(fbi->screen_base);
3817         release_mem_region(fbi->fix.smem_start, fbi->fix.smem_len);
3818         return 0;
3819 }
3820 #endif
3821
3822 static int init_lcdc_win(struct rk_lcdc_driver *dev_drv,
3823                          struct rk_lcdc_win *def_win)
3824 {
3825         int i;
3826         int lcdc_win_num = dev_drv->lcdc_win_num;
3827
3828         for (i = 0; i < lcdc_win_num; i++) {
3829                 struct rk_lcdc_win *win = NULL;
3830                 win = kzalloc(sizeof(struct rk_lcdc_win), GFP_KERNEL);
3831                 if (!win) {
3832                         dev_err(dev_drv->dev, "kzmalloc for win fail!");
3833                         return -ENOMEM;
3834                 }
3835
3836                 strcpy(win->name, def_win[i].name);
3837                 win->id = def_win[i].id;
3838                 win->support_3d = def_win[i].support_3d;
3839                 dev_drv->win[i] = win;
3840         }
3841
3842         return 0;
3843 }
3844
3845 static int init_lcdc_device_driver(struct rk_fb *rk_fb,
3846                                    struct rk_lcdc_win *def_win, int index)
3847 {
3848         struct rk_lcdc_driver *dev_drv = rk_fb->lcdc_dev_drv[index];
3849         struct rk_screen *screen = devm_kzalloc(dev_drv->dev,
3850                                                 sizeof(struct rk_screen),
3851                                                 GFP_KERNEL);
3852
3853         if (!screen) {
3854                 dev_err(dev_drv->dev, "malloc screen for lcdc%d fail!",
3855                         dev_drv->id);
3856                 return -ENOMEM;
3857         }
3858
3859         screen->screen_id = 0;
3860         screen->lcdc_id = dev_drv->id;
3861         screen->overscan.left = 100;
3862         screen->overscan.top = 100;
3863         screen->overscan.right = 100;
3864         screen->overscan.bottom = 100;
3865
3866         screen->x_mirror = dev_drv->rotate_mode & X_MIRROR;
3867         screen->y_mirror = dev_drv->rotate_mode & Y_MIRROR;
3868
3869         dev_drv->screen0 = screen;
3870         dev_drv->cur_screen = screen;
3871         /* devie use one lcdc + rk61x scaler for dual display */
3872         if (rk_fb->disp_mode == ONE_DUAL) {
3873                 struct rk_screen *screen1 =
3874                                 devm_kzalloc(dev_drv->dev,
3875                                              sizeof(struct rk_screen),
3876                                              GFP_KERNEL);
3877                 if (!screen1) {
3878                         dev_err(dev_drv->dev, "malloc screen1 for lcdc%d fail!",
3879                                 dev_drv->id);
3880                         return -ENOMEM;
3881                 }
3882                 screen1->screen_id = 1;
3883                 screen1->lcdc_id = 1;
3884                 dev_drv->screen1 = screen1;
3885         }
3886         sprintf(dev_drv->name, "lcdc%d", dev_drv->id);
3887         init_lcdc_win(dev_drv, def_win);
3888         init_completion(&dev_drv->frame_done);
3889         spin_lock_init(&dev_drv->cpl_lock);
3890         mutex_init(&dev_drv->fb_win_id_mutex);
3891         dev_drv->ops->fb_win_remap(dev_drv, dev_drv->fb_win_map);
3892         dev_drv->first_frame = 1;
3893         dev_drv->overscan.left = 100;
3894         dev_drv->overscan.top = 100;
3895         dev_drv->overscan.right = 100;
3896         dev_drv->overscan.bottom = 100;
3897         rk_disp_pwr_ctr_parse_dt(dev_drv);
3898         if (dev_drv->prop == PRMRY) {
3899                 if (dev_drv->ops->set_dsp_cabc)
3900                         dev_drv->ops->set_dsp_cabc(dev_drv, dev_drv->cabc_mode);
3901                 rk_fb_set_prmry_screen(screen);
3902                 rk_fb_get_prmry_screen(screen);
3903         }
3904         dev_drv->trsm_ops = rk_fb_trsm_ops_get(screen->type);
3905         if (dev_drv->prop != PRMRY)
3906                 rk_fb_get_prmry_screen(screen);
3907         dev_drv->output_color = screen->color_mode;
3908
3909         return 0;
3910 }
3911
3912 #ifdef CONFIG_LOGO_LINUX_BMP
3913 static struct linux_logo *bmp_logo;
3914 static int fb_prewine_bmp_logo(struct fb_info *info, int rotate)
3915 {
3916         bmp_logo = fb_find_logo(24);
3917         if (bmp_logo == NULL) {
3918                 printk(KERN_INFO "%s error\n", __func__);
3919                 return 0;
3920         }
3921         return 1;
3922 }
3923
3924 static void fb_show_bmp_logo(struct fb_info *info, int rotate)
3925 {
3926         unsigned char *src = bmp_logo->data;
3927         unsigned char *dst = info->screen_base;
3928         int i;
3929         unsigned int Needwidth = (*(src - 24) << 8) | (*(src - 23));
3930         unsigned int Needheight = (*(src - 22) << 8) | (*(src - 21));
3931
3932         for (i = 0; i < Needheight; i++)
3933                 memcpy(dst + info->var.xres * i * 4,
3934                        src + bmp_logo->width * i * 4, Needwidth * 4);
3935 }
3936 #endif
3937
3938 /*
3939  * check if the primary lcdc has registerd,
3940  * the primary lcdc mas register first
3941  */
3942 bool is_prmry_rk_lcdc_registered(void)
3943 {
3944         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3945
3946         if (rk_fb->lcdc_dev_drv[0])
3947                 return true;
3948         else
3949                 return false;
3950 }
3951
3952 int rk_fb_register(struct rk_lcdc_driver *dev_drv,
3953                    struct rk_lcdc_win *win, int id)
3954 {
3955         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3956         struct fb_info *fbi;
3957         struct rk_fb_par *fb_par = NULL;
3958         int i = 0, ret = 0, index = 0;
3959
3960         if (rk_fb->num_lcdc == RK30_MAX_LCDC_SUPPORT)
3961                 return -ENXIO;
3962
3963         for (i = 0; i < RK30_MAX_LCDC_SUPPORT; i++) {
3964                 if (!rk_fb->lcdc_dev_drv[i]) {
3965                         rk_fb->lcdc_dev_drv[i] = dev_drv;
3966                         rk_fb->lcdc_dev_drv[i]->id = id;
3967                         rk_fb->num_lcdc++;
3968                         break;
3969                 }
3970         }
3971
3972         index = i;
3973         init_lcdc_device_driver(rk_fb, win, index);
3974         dev_drv->fb_index_base = rk_fb->num_fb;
3975         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3976                 fbi = framebuffer_alloc(0, &fb_pdev->dev);
3977                 if (!fbi) {
3978                         dev_err(&fb_pdev->dev, "fb framebuffer_alloc fail!");
3979                         ret = -ENOMEM;
3980                 }
3981                 fb_par = devm_kzalloc(&fb_pdev->dev, sizeof(struct rk_fb_par),
3982                                       GFP_KERNEL);
3983                 if (!fb_par) {
3984                         dev_err(&fb_pdev->dev, "malloc fb_par for fb%d fail!",
3985                                 rk_fb->num_fb);
3986                         return -ENOMEM;
3987                 }
3988                 fb_par->id = rk_fb->num_fb;
3989                 fb_par->lcdc_drv = dev_drv;
3990                 fbi->par = (void *)fb_par;
3991                 fbi->var = def_var;
3992                 fbi->fix = def_fix;
3993                 sprintf(fbi->fix.id, "fb%d", rk_fb->num_fb);
3994                 fb_videomode_to_var(&fbi->var, &dev_drv->cur_screen->mode);
3995                 fbi->var.grayscale |=
3996                     (fbi->var.xres << 8) + (fbi->var.yres << 20);
3997 #if defined(CONFIG_LOGO_LINUX_BMP)
3998                 fbi->var.bits_per_pixel = 32;
3999 #else
4000                 fbi->var.bits_per_pixel = 16;
4001 #endif
4002                 fbi->fix.line_length =
4003                     (fbi->var.xres_virtual) * (fbi->var.bits_per_pixel >> 3);
4004                 fbi->var.width = dev_drv->cur_screen->width;
4005                 fbi->var.height = dev_drv->cur_screen->height;
4006                 fbi->var.pixclock = dev_drv->pixclock;
4007                 if (dev_drv->iommu_enabled)
4008                         fb_ops.fb_mmap = rk_fb_mmap;
4009                 fbi->fbops = &fb_ops;
4010                 fbi->flags = FBINFO_FLAG_DEFAULT;
4011                 fbi->pseudo_palette = dev_drv->win[i]->pseudo_pal;
4012                 ret = register_framebuffer(fbi);
4013                 if (ret < 0) {
4014                         dev_err(&fb_pdev->dev,
4015                                 "%s fb%d register_framebuffer fail!\n",
4016                                 __func__, rk_fb->num_fb);
4017                         return ret;
4018                 }
4019                 rkfb_create_sysfs(fbi);
4020                 rk_fb->fb[rk_fb->num_fb] = fbi;
4021                 dev_info(fbi->dev, "rockchip framebuffer registerd:%s\n",
4022                          fbi->fix.id);
4023                 rk_fb->num_fb++;
4024
4025                 if (i == 0) {
4026                         init_waitqueue_head(&dev_drv->vsync_info.wait);
4027                         init_waitqueue_head(&dev_drv->update_regs_wait);
4028                         ret = device_create_file(fbi->dev, &dev_attr_vsync);
4029                         if (ret)
4030                                 dev_err(fbi->dev,
4031                                         "failed to create vsync file\n");
4032                         dev_drv->vsync_info.thread =
4033                             kthread_run(rk_fb_wait_for_vsync_thread, dev_drv,
4034                                         "fb-vsync");
4035                         if (dev_drv->vsync_info.thread == ERR_PTR(-ENOMEM)) {
4036                                 dev_err(fbi->dev,
4037                                         "failed to run vsync thread\n");
4038                                 dev_drv->vsync_info.thread = NULL;
4039                         }
4040                         dev_drv->vsync_info.active = 1;
4041
4042                         mutex_init(&dev_drv->output_lock);
4043
4044                         INIT_LIST_HEAD(&dev_drv->update_regs_list);
4045                         mutex_init(&dev_drv->update_regs_list_lock);
4046                         init_kthread_worker(&dev_drv->update_regs_worker);
4047
4048                         dev_drv->update_regs_thread =
4049                             kthread_run(kthread_worker_fn,
4050                                         &dev_drv->update_regs_worker, "rk-fb");
4051                         if (IS_ERR(dev_drv->update_regs_thread)) {
4052                                 int err = PTR_ERR(dev_drv->update_regs_thread);
4053                                 dev_drv->update_regs_thread = NULL;
4054
4055                                 printk("failed to run update_regs thread\n");
4056                                 return err;
4057                         }
4058                         init_kthread_work(&dev_drv->update_regs_work,
4059                                           rk_fb_update_regs_handler);
4060
4061                         dev_drv->timeline =
4062                             sw_sync_timeline_create("fb-timeline");
4063                         dev_drv->timeline_max = 1;
4064                 }
4065         }
4066
4067         /* show logo for primary display device */
4068 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
4069         if (dev_drv->prop == PRMRY) {
4070                 struct fb_info *main_fbi = rk_fb->fb[0];
4071                 main_fbi->fbops->fb_open(main_fbi, 1);
4072
4073 #if defined(CONFIG_ROCKCHIP_IOMMU)
4074                 if (dev_drv->iommu_enabled) {
4075                         if (dev_drv->mmu_dev)
4076                                 rockchip_iovmm_set_fault_handler(dev_drv->dev,
4077                                                 rk_fb_sysmmu_fault_handler);
4078                 }
4079 #endif
4080
4081                 rk_fb_alloc_buffer(main_fbi, 0);        /* only alloc memory for main fb */
4082                 dev_drv->uboot_logo = support_uboot_display();
4083                 if (support_uboot_display()) {
4084                         /*
4085                         if (dev_drv->iommu_enabled)
4086                                 rk_fb_copy_from_loader(main_fbi);
4087                         */
4088                         return 0;
4089                 }
4090                 main_fbi->fbops->fb_set_par(main_fbi);
4091 #if  defined(CONFIG_LOGO_LINUX_BMP)
4092                 if (fb_prewine_bmp_logo(main_fbi, FB_ROTATE_UR)) {
4093                         fb_set_cmap(&main_fbi->cmap, main_fbi);
4094                         fb_show_bmp_logo(main_fbi, FB_ROTATE_UR);
4095                 }
4096 #else
4097                 if (fb_prepare_logo(main_fbi, FB_ROTATE_UR)) {
4098                         fb_set_cmap(&main_fbi->cmap, main_fbi);
4099                         fb_show_logo(main_fbi, FB_ROTATE_UR);
4100                 }
4101 #endif
4102                 main_fbi->fbops->fb_pan_display(&main_fbi->var, main_fbi);
4103         } else {
4104                 struct fb_info *extend_fbi = rk_fb->fb[rk_fb->num_fb >> 1];
4105                 int extend_fb_id = get_extend_fb_id(extend_fbi);
4106
4107                 rk_fb_alloc_buffer(extend_fbi, extend_fb_id);
4108         }
4109 #endif
4110         return 0;
4111 }
4112
4113 int rk_fb_unregister(struct rk_lcdc_driver *dev_drv)
4114 {
4115         struct rk_fb *fb_inf = platform_get_drvdata(fb_pdev);
4116         struct fb_info *fbi;
4117         int fb_index_base = dev_drv->fb_index_base;
4118         int fb_num = dev_drv->lcdc_win_num;
4119         int i = 0;
4120
4121         if (fb_inf->lcdc_dev_drv[i]->vsync_info.thread) {
4122                 fb_inf->lcdc_dev_drv[i]->vsync_info.irq_stop = 1;
4123                 kthread_stop(fb_inf->lcdc_dev_drv[i]->vsync_info.thread);
4124         }
4125
4126         for (i = 0; i < fb_num; i++)
4127                 kfree(dev_drv->win[i]);
4128
4129         for (i = fb_index_base; i < (fb_index_base + fb_num); i++) {
4130                 fbi = fb_inf->fb[i];
4131                 unregister_framebuffer(fbi);
4132                 /* rk_release_fb_buffer(fbi); */
4133                 framebuffer_release(fbi);
4134         }
4135         fb_inf->lcdc_dev_drv[dev_drv->id] = NULL;
4136         fb_inf->num_lcdc--;
4137
4138         return 0;
4139 }
4140
4141 static int rk_fb_probe(struct platform_device *pdev)
4142 {
4143         struct rk_fb *rk_fb = NULL;
4144         struct device_node *np = pdev->dev.of_node;
4145         u32 mode;
4146
4147         if (!np) {
4148                 dev_err(&pdev->dev, "Missing device tree node.\n");
4149                 return -EINVAL;
4150         }
4151
4152         rk_fb = devm_kzalloc(&pdev->dev, sizeof(struct rk_fb), GFP_KERNEL);
4153         if (!rk_fb) {
4154                 dev_err(&pdev->dev, "kmalloc for rk fb fail!");
4155                 return -ENOMEM;
4156         }
4157         platform_set_drvdata(pdev, rk_fb);
4158
4159         if (!of_property_read_u32(np, "rockchip,disp-mode", &mode)) {
4160                 rk_fb->disp_mode = mode;
4161
4162         } else {
4163                 dev_err(&pdev->dev, "no disp-mode node found!");
4164                 return -ENODEV;
4165         }
4166
4167         if (!of_property_read_u32(np, "rockchip,disp-policy", &mode)) {
4168                 rk_fb->disp_policy = mode;
4169                 pr_info("fb disp policy is %s\n", rk_fb->disp_policy ? "box":"sdk");
4170         }
4171
4172         if (!of_property_read_u32(np, "rockchip,uboot-logo-on", &uboot_logo_on))
4173                 printk(KERN_DEBUG "uboot-logo-on:%d\n", uboot_logo_on);
4174
4175         dev_set_name(&pdev->dev, "rockchip-fb");
4176 #if defined(CONFIG_ION_ROCKCHIP)
4177         rk_fb->ion_client = rockchip_ion_client_create("rk_fb");
4178         if (IS_ERR(rk_fb->ion_client)) {
4179                 dev_err(&pdev->dev, "failed to create ion client for rk fb");
4180                 return PTR_ERR(rk_fb->ion_client);
4181         } else {
4182                 dev_info(&pdev->dev, "rk fb ion client create success!\n");
4183         }
4184 #endif
4185
4186         fb_pdev = pdev;
4187         dev_info(&pdev->dev, "rockchip framebuffer driver probe\n");
4188         return 0;
4189 }
4190
4191 static int rk_fb_remove(struct platform_device *pdev)
4192 {
4193         struct rk_fb *rk_fb = platform_get_drvdata(pdev);
4194
4195         kfree(rk_fb);
4196         platform_set_drvdata(pdev, NULL);
4197         return 0;
4198 }
4199
4200 static void rk_fb_shutdown(struct platform_device *pdev)
4201 {
4202         struct rk_fb *rk_fb = platform_get_drvdata(pdev);
4203         int i;
4204
4205         for (i = 0; i < rk_fb->num_lcdc; i++) {
4206                 if (!rk_fb->lcdc_dev_drv[i])
4207                         continue;
4208         }
4209 }
4210
4211 static const struct of_device_id rkfb_dt_ids[] = {
4212         {.compatible = "rockchip,rk-fb",},
4213         {}
4214 };
4215
4216 static struct platform_driver rk_fb_driver = {
4217         .probe = rk_fb_probe,
4218         .remove = rk_fb_remove,
4219         .driver = {
4220                    .name = "rk-fb",
4221                    .owner = THIS_MODULE,
4222                    .of_match_table = of_match_ptr(rkfb_dt_ids),
4223                    },
4224         .shutdown = rk_fb_shutdown,
4225 };
4226
4227 static int __init rk_fb_init(void)
4228 {
4229         return platform_driver_register(&rk_fb_driver);
4230 }
4231
4232 static void __exit rk_fb_exit(void)
4233 {
4234         platform_driver_unregister(&rk_fb_driver);
4235 }
4236
4237 fs_initcall(rk_fb_init);
4238 module_exit(rk_fb_exit);