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                              win_data->data_format == YUV420_A))
1937                                 continue;
1938                         rk_fb_update_win(dev_drv, win, win_data);
1939                         win->state = 1;
1940                         dev_drv->ops->set_par(dev_drv, i);
1941                         dev_drv->ops->pan_display(dev_drv, i);
1942 #if defined(CONFIG_ROCKCHIP_IOMMU)
1943                         if (dev_drv->iommu_enabled) {
1944                                 g_last_addr[i] = win_data->reg_area_data[0].smem_start +
1945                                         win_data->reg_area_data[0].y_offset;
1946                         }
1947 #endif
1948                 } else {
1949                         win->z_order = -1;
1950                         win->state = 0;
1951                 }
1952         }
1953         dev_drv->ops->ovl_mgr(dev_drv, 0, 1);
1954         if (rk_fb->disp_policy == DISPLAY_POLICY_BOX)
1955                 dev_drv->ops->cfg_done(dev_drv);
1956         if ((rk_fb->disp_mode == DUAL)
1957             && (hdmi_get_hotplug() == HDMI_HPD_ACTIVED)
1958             && hdmi_switch_complete) {
1959                 ext_dev_drv = rk_get_extend_lcdc_drv();
1960                 if (!ext_dev_drv) {
1961                         printk(KERN_ERR "hdmi lcdc driver not found!\n");
1962                         goto ext_win_exit;
1963                 }
1964
1965                 /*
1966                   * For RK3288: win0 and win1 have only one area and support scale
1967                   * but win2 and win3 don't support scale
1968                   * so hdmi only use win0 or win1
1969                   */
1970                 for (i = 0; i < 2; i++) {
1971                         win = dev_drv->win[i];
1972                         ext_win = ext_dev_drv->win[i];
1973                         ext_win->state = win->state;
1974                         ext_win->id = win->id;
1975                         if (!ext_win->state)
1976                                 continue;
1977                         rk_fb_update_ext_win(ext_dev_drv, dev_drv, ext_win, win);
1978                         rk_fb_set_ext_win_buffer(ext_win, win,
1979                                                  ext_dev_drv->rotate_mode,
1980                                                  ext_dev_drv->iommu_enabled);
1981
1982                         if (ext_dev_drv->rotate_mode > X_Y_MIRROR)
1983                                 rk_fb_win_rotate(ext_win, win,
1984                                                  ext_dev_drv->rotate_mode,
1985                                                  ext_dev_drv->iommu_enabled);
1986
1987                         ext_dev_drv->ops->set_par(ext_dev_drv, i);
1988                         ext_dev_drv->ops->pan_display(ext_dev_drv, i);
1989                 }
1990
1991                 ext_dev_drv->ops->cfg_done(ext_dev_drv);
1992         }
1993 ext_win_exit:
1994         dev_drv->ops->cfg_done(dev_drv);
1995
1996         do {
1997                 timestamp = dev_drv->vsync_info.timestamp;
1998                 timeout = wait_event_interruptible_timeout(dev_drv->vsync_info.wait,
1999                                 ktime_compare(dev_drv->vsync_info.timestamp, timestamp) > 0,
2000                                 msecs_to_jiffies(25));
2001                 if ((rk_fb->disp_mode == DUAL) &&
2002                     (hdmi_get_hotplug() == HDMI_HPD_ACTIVED) &&
2003                     hdmi_switch_complete) {
2004                         /*
2005                          * If dual output, we need make sure the extend display
2006                          * cfg take effect before release fence.
2007                          */
2008                         ext_dev_drv = rk_get_extend_lcdc_drv();
2009                         timeout = wait_event_interruptible_timeout(ext_dev_drv->vsync_info.wait,
2010                                         ktime_compare(ext_dev_drv->vsync_info.timestamp, timestamp) > 0,
2011                                         msecs_to_jiffies(25));
2012                 }
2013
2014                 dev_drv->ops->get_dsp_addr(dev_drv, dsp_addr);
2015                 wait_for_vsync = false;
2016                 for (i = 0; i < dev_drv->lcdc_win_num; i++) {
2017                         if (dev_drv->win[i]->state == 1) {
2018                                 if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
2019                                     (dev_drv->win[i]->format == YUV420 ||
2020                                      dev_drv->win[i]->format == YUV420_A ||
2021                                      !strcmp(dev_drv->win[i]->name, "hwc"))) {
2022                                         continue;
2023                                 } else {
2024                                         u32 new_start =
2025                                             dev_drv->win[i]->area[0].smem_start +
2026                                             dev_drv->win[i]->area[0].y_offset;
2027                                         u32 reg_start = dsp_addr[i];
2028
2029                                         if ((rk_fb->disp_policy ==
2030                                              DISPLAY_POLICY_BOX) &&
2031                                             (new_start == 0x0 ||
2032                                              dev_drv->suspend_flag))
2033                                                 continue;
2034                                         if (unlikely(new_start != reg_start)) {
2035                                                 wait_for_vsync = true;
2036                                                 dev_info(dev_drv->dev,
2037                                                        "win%d:new_addr:0x%08x cur_addr:0x%08x--%d\n",
2038                                                        i, new_start, reg_start, 101 - count);
2039                                                 break;
2040                                         }
2041                                 }
2042                         }
2043                 }
2044         } while (wait_for_vsync && count--);
2045 #ifdef H_USE_FENCE
2046         sw_sync_timeline_inc(dev_drv->timeline, 1);
2047 #endif
2048         if (!g_first_buf) {
2049 #if defined(CONFIG_ROCKCHIP_IOMMU)
2050                 if (dev_drv->iommu_enabled) {
2051                         freed_index = 0;
2052                         g_last_timeout = timeout;
2053                 }
2054 #endif
2055                 for (i = 0; i < g_last_win_num; i++)
2056                         rk_fb_free_dma_buf(dev_drv, &g_reg_win_data[i]);
2057
2058 #if defined(CONFIG_ROCKCHIP_IOMMU)
2059                 if (dev_drv->iommu_enabled)
2060                         freed_addr[freed_index] = 0xfefefefe;
2061 #endif
2062         }
2063         for (i = 0; i < regs->win_num; i++) {
2064                 memcpy(&g_reg_win_data[i], &(regs->reg_win_data[i]),
2065                        sizeof(struct rk_fb_reg_win_data));
2066         }
2067         g_last_win_num = regs->win_num;
2068         g_first_buf = 0;
2069 }
2070
2071 static void rk_fb_update_regs_handler(struct kthread_work *work)
2072 {
2073         struct rk_lcdc_driver *dev_drv =
2074             container_of(work, struct rk_lcdc_driver, update_regs_work);
2075         struct rk_fb_reg_data *data, *next;
2076         /* struct list_head saved_list; */
2077
2078         mutex_lock(&dev_drv->update_regs_list_lock);
2079         saved_list = dev_drv->update_regs_list;
2080         list_replace_init(&dev_drv->update_regs_list, &saved_list);
2081         mutex_unlock(&dev_drv->update_regs_list_lock);
2082
2083         list_for_each_entry_safe(data, next, &saved_list, list) {
2084                 rk_fb_update_reg(dev_drv, data);
2085                 list_del(&data->list);
2086                 kfree(data);
2087         }
2088
2089         if (dev_drv->wait_fs && list_empty(&dev_drv->update_regs_list))
2090                 wake_up(&dev_drv->update_regs_wait);
2091 }
2092
2093 static int rk_fb_check_config_var(struct rk_fb_area_par *area_par,
2094                                   struct rk_screen *screen)
2095 {
2096         if ((area_par->x_offset + area_par->xact > area_par->xvir) ||
2097             (area_par->xact <= 0) || (area_par->yact <= 0) ||
2098             (area_par->xvir <= 0) || (area_par->yvir <= 0)) {
2099                 pr_err("check config var fail 0:\n"
2100                        "x_offset=%d,xact=%d,xvir=%d\n",
2101                        area_par->x_offset, area_par->xact, area_par->xvir);
2102                 return -EINVAL;
2103         }
2104
2105         if ((area_par->xpos + area_par->xsize > screen->mode.xres) ||
2106             (area_par->ypos + area_par->ysize > screen->mode.yres) ||
2107             (area_par->xsize <= 0) || (area_par->ysize <= 0)) {
2108                 pr_err("check config var fail 1:\n"
2109                        "xpos=%d,xsize=%d,xres=%d\n"
2110                        "ypos=%d,ysize=%d,yres=%d\n",
2111                        area_par->xpos, area_par->xsize, screen->mode.xres,
2112                        area_par->ypos, area_par->ysize, screen->mode.yres);
2113                 return -EINVAL;
2114         }
2115         return 0;
2116 }
2117
2118 static int rk_fb_set_win_buffer(struct fb_info *info,
2119                                 struct rk_fb_win_par *win_par,
2120                                 struct rk_fb_reg_win_data *reg_win_data)
2121 {
2122         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
2123         struct fb_fix_screeninfo *fix = &info->fix;
2124         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2125         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2126         struct rk_screen *screen = dev_drv->cur_screen;
2127         struct rk_screen primary_screen;
2128         struct fb_info *fbi = rk_fb->fb[0];
2129         int i, ion_fd, acq_fence_fd;
2130         u32 xvir, yvir;
2131         u32 xoffset, yoffset;
2132
2133         struct ion_handle *hdl;
2134         size_t len;
2135         int index_buf;
2136         u8 fb_data_fmt;
2137         u8 pixel_width;
2138         u32 vir_width_bit;
2139         u32 stride, uv_stride;
2140         u32 stride_32bit_1;
2141         u32 stride_32bit_2;
2142         u16 uv_x_off, uv_y_off, uv_y_act;
2143         u8 is_pic_yuv = 0;
2144         u8 ppixel_a = 0, global_a = 0;
2145         ion_phys_addr_t phy_addr;
2146         int ret = 0;
2147
2148         reg_win_data->reg_area_data[0].smem_start = -1;
2149         reg_win_data->area_num = 0;
2150         fbi = rk_fb->fb[reg_win_data->win_id];
2151         if (win_par->area_par[0].phy_addr == 0) {
2152                 for (i = 0; i < RK_WIN_MAX_AREA; i++) {
2153                         ion_fd = win_par->area_par[i].ion_fd;
2154                         if (ion_fd > 0) {
2155                                 hdl =
2156                                     ion_import_dma_buf(rk_fb->ion_client,
2157                                                        ion_fd);
2158                                 if (IS_ERR(hdl)) {
2159                                         pr_info
2160                                             ("%s: Could not import handle: %d\n",
2161                                              __func__, (int)hdl);
2162                                         /*return -EINVAL; */
2163                                         break;
2164                                 }
2165                                 fbi->screen_base =
2166                                     ion_map_kernel(rk_fb->ion_client, hdl);
2167                                 reg_win_data->area_num++;
2168                                 reg_win_data->reg_area_data[i].ion_handle = hdl;
2169 #ifndef CONFIG_ROCKCHIP_IOMMU
2170                                 ret = ion_phys(rk_fb->ion_client, hdl, &phy_addr,
2171                                                 &len);
2172 #else
2173                                 if (dev_drv->iommu_enabled)
2174                                         ret = ion_map_iommu(dev_drv->dev,
2175                                                                 rk_fb->ion_client,
2176                                                                 hdl,
2177                                                                 (unsigned long *)&phy_addr,
2178                                                                 (unsigned long *)&len);
2179                                 else
2180                                         ret = ion_phys(rk_fb->ion_client, hdl,
2181                                                         &phy_addr, &len);
2182 #endif
2183                                 if (ret < 0) {
2184                                         dev_err(fbi->dev, "ion map to get phy addr failed\n");
2185                                         ion_free(rk_fb->ion_client, hdl);
2186                                         return -ENOMEM;
2187                                 }
2188                                 reg_win_data->reg_area_data[i].smem_start = phy_addr;
2189                                 reg_win_data->area_buf_num++;
2190                                 reg_win_data->reg_area_data[i].index_buf = 1;
2191                         }
2192                 }
2193         } else {
2194                 reg_win_data->reg_area_data[0].smem_start =
2195                     win_par->area_par[0].phy_addr;
2196                 reg_win_data->area_num = 1;
2197                 fbi->screen_base = phys_to_virt(win_par->area_par[0].phy_addr);
2198         }
2199
2200         if (reg_win_data->area_num == 0)
2201                 return 0;
2202
2203         for (i = 0; i < reg_win_data->area_num; i++) {
2204                 acq_fence_fd = win_par->area_par[i].acq_fence_fd;
2205                 index_buf = reg_win_data->reg_area_data[i].index_buf;
2206                 if ((acq_fence_fd > 0) && (index_buf == 1)) {
2207                         reg_win_data->reg_area_data[i].acq_fence =
2208                             sync_fence_fdget(win_par->area_par[i].acq_fence_fd);
2209                 }
2210         }
2211         fb_data_fmt = rk_fb_data_fmt(win_par->data_format, 0);
2212         reg_win_data->data_format = fb_data_fmt;
2213         pixel_width = rk_fb_pixel_width(fb_data_fmt);
2214
2215         ppixel_a = ((fb_data_fmt == ARGB888) ||
2216                     (fb_data_fmt == ABGR888)) ? 1 : 0;
2217         global_a = (win_par->g_alpha_val == 0) ? 0 : 1;
2218         reg_win_data->alpha_en = ppixel_a | global_a;
2219         reg_win_data->g_alpha_val = win_par->g_alpha_val;
2220         reg_win_data->alpha_mode = win_par->alpha_mode;
2221         if (reg_win_data->reg_area_data[0].smem_start > 0) {
2222                 reg_win_data->z_order = win_par->z_order;
2223                 reg_win_data->win_id = win_par->win_id;
2224         } else {
2225                 reg_win_data->z_order = -1;
2226                 reg_win_data->win_id = -1;
2227         }
2228
2229         rk_fb_get_prmry_screen(&primary_screen);
2230         for (i = 0; i < reg_win_data->area_num; i++) {
2231                 if (rk_fb->disp_policy == DISPLAY_POLICY_BOX)
2232                         rk_fb_check_config_var(&win_par->area_par[i], screen);
2233                 else
2234                         rk_fb_check_config_var(&win_par->area_par[i], &primary_screen);
2235                 /* visiable pos in panel */
2236                 reg_win_data->reg_area_data[i].xpos = win_par->area_par[i].xpos;
2237                 reg_win_data->reg_area_data[i].ypos = win_par->area_par[i].ypos;
2238
2239                 /* realy size in panel */
2240                 reg_win_data->reg_area_data[i].xsize = win_par->area_par[i].xsize;
2241                 reg_win_data->reg_area_data[i].ysize = win_par->area_par[i].ysize;
2242
2243                 /* realy size in panel */
2244                 reg_win_data->reg_area_data[i].xact = win_par->area_par[i].xact;
2245                 reg_win_data->reg_area_data[i].yact = win_par->area_par[i].yact;
2246
2247                 xoffset = win_par->area_par[i].x_offset;        /* buf offset */
2248                 yoffset = win_par->area_par[i].y_offset;
2249                 xvir = win_par->area_par[i].xvir;
2250                 reg_win_data->reg_area_data[i].xvir = xvir;
2251                 yvir = win_par->area_par[i].yvir;
2252                 reg_win_data->reg_area_data[i].yvir = yvir;
2253
2254                 vir_width_bit = pixel_width * xvir;
2255                 /* pixel_width = byte_num*8 */
2256                 stride_32bit_1 = ((vir_width_bit + 31) & (~31)) / 8;
2257                 stride_32bit_2 = ((vir_width_bit * 2 + 31) & (~31)) / 8;
2258
2259                 stride = stride_32bit_1;        /* default rgb */
2260                 fix->line_length = stride;
2261                 reg_win_data->reg_area_data[i].y_vir_stride = stride >> 2;
2262
2263                 /* x y mirror ,jump line
2264                  * reg_win_data->reg_area_data[i].y_offset =
2265                  *              yoffset*stride+xoffset*pixel_width/8;
2266                  */
2267                 if (screen->y_mirror == 1) {
2268                         if (screen->interlace == 1) {
2269                                 reg_win_data->reg_area_data[i].y_offset =
2270                                     yoffset * stride * 2 +
2271                                     ((reg_win_data->reg_area_data[i].yact - 1) * 2 + 1) * stride +
2272                                     xoffset * pixel_width / 8;
2273                         } else {
2274                                 reg_win_data->reg_area_data[i].y_offset =
2275                                     yoffset * stride +
2276                                     (reg_win_data->reg_area_data[i].yact - 1) * stride +
2277                                     xoffset * pixel_width / 8;
2278                         }
2279                 } else {
2280                         if (screen->interlace == 1) {
2281                                 reg_win_data->reg_area_data[i].y_offset =
2282                                     yoffset * stride * 2 +
2283                                     xoffset * pixel_width / 8;
2284                         } else {
2285                                 reg_win_data->reg_area_data[i].y_offset =
2286                                     yoffset * stride +
2287                                     xoffset * pixel_width / 8;
2288                         }
2289                 }
2290         }
2291         switch (fb_data_fmt) {
2292         case YUV422:
2293         case YUV422_A:
2294                 is_pic_yuv = 1;
2295                 stride = stride_32bit_1;
2296                 uv_stride = stride_32bit_1 >> 1;
2297                 uv_x_off = xoffset >> 1;
2298                 uv_y_off = yoffset;
2299                 fix->line_length = stride;
2300                 uv_y_act = win_par->area_par[0].yact >> 1;
2301                 break;
2302         case YUV420:            /* 420sp */
2303         case YUV420_A:
2304                 is_pic_yuv = 1;
2305                 stride = stride_32bit_1;
2306                 uv_stride = stride_32bit_1;
2307                 uv_x_off = xoffset;
2308                 uv_y_off = yoffset >> 1;
2309                 fix->line_length = stride;
2310                 uv_y_act = win_par->area_par[0].yact >> 1;
2311                 break;
2312         case YUV444:
2313         case YUV444_A:
2314                 is_pic_yuv = 1;
2315                 stride = stride_32bit_1;
2316                 uv_stride = stride_32bit_2;
2317                 uv_x_off = xoffset * 2;
2318                 uv_y_off = yoffset;
2319                 fix->line_length = stride << 2;
2320                 uv_y_act = win_par->area_par[0].yact;
2321                 break;
2322         default:
2323                 break;
2324         }
2325         if (is_pic_yuv == 1) {
2326                 reg_win_data->reg_area_data[0].cbr_start =
2327                     reg_win_data->reg_area_data[0].smem_start + xvir * yvir;
2328                 reg_win_data->reg_area_data[0].uv_vir_stride = uv_stride >> 2;
2329                 if (screen->y_mirror == 1) {
2330                         if (screen->interlace == 1) {
2331                                 reg_win_data->reg_area_data[0].c_offset =
2332                                     uv_y_off * uv_stride * 2 +
2333                                     ((uv_y_act - 1) * 2 + 1) * uv_stride +
2334                                     uv_x_off * pixel_width / 8;
2335                         } else {
2336                                 reg_win_data->reg_area_data[0].c_offset =
2337                                     uv_y_off * uv_stride +
2338                                     (uv_y_act - 1) * uv_stride +
2339                                     uv_x_off * pixel_width / 8;
2340                         }
2341                 } else {
2342                         if (screen->interlace == 1) {
2343                                 reg_win_data->reg_area_data[0].c_offset =
2344                                     uv_y_off * uv_stride * 2 +
2345                                     uv_x_off * pixel_width / 8;
2346                         } else {
2347                                 reg_win_data->reg_area_data[0].c_offset =
2348                                     uv_y_off * uv_stride +
2349                                     uv_x_off * pixel_width / 8;
2350                         }
2351                 }
2352         }
2353
2354         /* record buffer information for rk_fb_disp_scale to prevent fence timeout
2355          * because rk_fb_disp_scale will call function info->fbops->fb_set_par(info);
2356          */
2357         info->var.yoffset = yoffset;
2358         info->var.xoffset = xoffset;
2359         return 0;
2360 }
2361
2362 static int rk_fb_set_win_config(struct fb_info *info,
2363                                 struct rk_fb_win_cfg_data *win_data)
2364 {
2365         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2366         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2367         struct rk_fb_reg_data *regs;
2368 #ifdef H_USE_FENCE
2369         struct sync_fence *release_fence[RK_MAX_BUF_NUM];
2370         struct sync_fence *retire_fence;
2371         struct sync_pt *release_sync_pt[RK_MAX_BUF_NUM];
2372         struct sync_pt *retire_sync_pt;
2373         char fence_name[20];
2374 #endif
2375         int ret = 0, i, j = 0;
2376         int list_is_empty = 0;
2377
2378         regs = kzalloc(sizeof(struct rk_fb_reg_data), GFP_KERNEL);
2379         if (!regs) {
2380                 printk(KERN_INFO "could not allocate rk_fb_reg_data\n");
2381                 ret = -ENOMEM;
2382                 return ret;
2383         }
2384
2385 /*
2386         regs->post_cfg.xpos = win_data->post_cfg.xpos;
2387         regs->post_cfg.ypos = win_data->post_cfg.ypos;
2388         regs->post_cfg.xsize = win_data->post_cfg.xsize;
2389         regs->post_cfg.ysize = win_data->post_cfg.xsize;
2390 */
2391
2392         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
2393                 if (win_data->win_par[i].win_id < dev_drv->lcdc_win_num) {
2394                         if (rk_fb_set_win_buffer(info, &win_data->win_par[i],
2395                                                         &regs->reg_win_data[j]))
2396                                 return -ENOMEM;
2397                         if (regs->reg_win_data[j].area_num > 0) {
2398                                 regs->win_num++;
2399                                 regs->buf_num +=
2400                                     regs->reg_win_data[j].area_buf_num;
2401                         }
2402                         j++;
2403                 } else {
2404                         printk(KERN_INFO "error:win_id bigger than lcdc_win_num\n");
2405                         printk(KERN_INFO "i=%d,win_id=%d\n", i,
2406                                win_data->win_par[i].win_id);
2407                 }
2408         }
2409
2410         mutex_lock(&dev_drv->output_lock);
2411         if (!(dev_drv->suspend_flag == 0)) {
2412                 rk_fb_update_reg(dev_drv, regs);
2413                 kfree(regs);
2414                 printk(KERN_INFO "suspend_flag = 1\n");
2415                 goto err;
2416         }
2417
2418         dev_drv->timeline_max++;
2419 #ifdef H_USE_FENCE
2420         for (i = 0; i < RK_MAX_BUF_NUM; i++) {
2421                 if (i < regs->buf_num) {
2422                         sprintf(fence_name, "fence%d", i);
2423                         win_data->rel_fence_fd[i] = get_unused_fd();
2424                         if (win_data->rel_fence_fd[i] < 0) {
2425                                 printk(KERN_INFO "rel_fence_fd=%d\n",
2426                                        win_data->rel_fence_fd[i]);
2427                                 ret = -EFAULT;
2428                                 goto err;
2429                         }
2430                         release_sync_pt[i] =
2431                             sw_sync_pt_create(dev_drv->timeline,
2432                                               dev_drv->timeline_max);
2433                         release_fence[i] =
2434                             sync_fence_create(fence_name, release_sync_pt[i]);
2435                         sync_fence_install(release_fence[i],
2436                                            win_data->rel_fence_fd[i]);
2437                 } else {
2438                         win_data->rel_fence_fd[i] = -1;
2439                 }
2440         }
2441
2442         win_data->ret_fence_fd = get_unused_fd();
2443         if (win_data->ret_fence_fd < 0) {
2444                 printk("ret_fence_fd=%d\n", win_data->ret_fence_fd);
2445                 ret = -EFAULT;
2446                 goto err;
2447         }
2448         retire_sync_pt =
2449             sw_sync_pt_create(dev_drv->timeline, dev_drv->timeline_max);
2450         retire_fence = sync_fence_create("ret_fence", retire_sync_pt);
2451         sync_fence_install(retire_fence, win_data->ret_fence_fd);
2452 #else
2453         for (i = 0; i < RK_MAX_BUF_NUM; i++)
2454                 win_data->rel_fence_fd[i] = -1;
2455
2456         win_data->ret_fence_fd = -1;
2457 #endif
2458         if (dev_drv->wait_fs == 0) {
2459                 mutex_lock(&dev_drv->update_regs_list_lock);
2460                 list_add_tail(&regs->list, &dev_drv->update_regs_list);
2461                 mutex_unlock(&dev_drv->update_regs_list_lock);
2462                 queue_kthread_work(&dev_drv->update_regs_worker,
2463                                    &dev_drv->update_regs_work);
2464         } else {
2465                 mutex_lock(&dev_drv->update_regs_list_lock);
2466                 list_is_empty = list_empty(&dev_drv->update_regs_list) &&
2467                                         list_empty(&saved_list);
2468                 mutex_unlock(&dev_drv->update_regs_list_lock);
2469                 if (!list_is_empty) {
2470                         ret = wait_event_timeout(dev_drv->update_regs_wait,
2471                                 list_empty(&dev_drv->update_regs_list) && list_empty(&saved_list),
2472                                 msecs_to_jiffies(60));
2473                         if (ret > 0)
2474                                 rk_fb_update_reg(dev_drv, regs);
2475                         else
2476                                 printk("%s: wait update_regs_wait timeout\n", __func__);
2477                 } else if (ret == 0) {
2478                         rk_fb_update_reg(dev_drv, regs);
2479                 }
2480                 kfree(regs);
2481         }
2482
2483 err:
2484         mutex_unlock(&dev_drv->output_lock);
2485         return ret;
2486 }
2487
2488 #if 1
2489 static int cfgdone_distlist[10] = { 0 };
2490
2491 static int cfgdone_index;
2492 static int cfgdone_lasttime;
2493
2494 int rk_get_real_fps(int before)
2495 {
2496         struct timespec now;
2497         int dist_curr;
2498         int dist_total = 0;
2499         int dist_count = 0;
2500         int dist_first = 0;
2501
2502         int index = cfgdone_index;
2503         int i = 0, fps = 0;
2504         int total;
2505
2506         if (before > 100)
2507                 before = 100;
2508         if (before < 0)
2509                 before = 0;
2510
2511         getnstimeofday(&now);
2512         dist_curr = (now.tv_sec * 1000000 + now.tv_nsec / 1000) -
2513                         cfgdone_lasttime;
2514         total = dist_curr;
2515         /*
2516            printk("fps: ");
2517          */
2518         for (i = 0; i < 10; i++) {
2519                 if (--index < 0)
2520                         index = 9;
2521                 total += cfgdone_distlist[index];
2522                 if (i == 0)
2523                         dist_first = cfgdone_distlist[index];
2524                 if (total < (before * 1000)) {
2525                         /*
2526                            printk("[%d:%d] ", dist_count, cfgdone_distlist[index]);
2527                          */
2528                         dist_total += cfgdone_distlist[index];
2529                         dist_count++;
2530                 } else {
2531                         break;
2532                 }
2533         }
2534
2535         /*
2536            printk("total %d, count %d, curr %d, ", dist_total, dist_count, dist_curr);
2537          */
2538         dist_curr = (dist_curr > dist_first) ? dist_curr : dist_first;
2539         dist_total += dist_curr;
2540         dist_count++;
2541
2542         if (dist_total > 0)
2543                 fps = (1000000 * dist_count) / dist_total;
2544         else
2545                 fps = 60;
2546
2547         /*
2548            printk("curr2 %d, fps=%d\n", dist_curr, fps);
2549          */
2550         return fps;
2551 }
2552 EXPORT_SYMBOL(rk_get_real_fps);
2553
2554 #endif
2555 #ifdef CONFIG_ROCKCHIP_IOMMU
2556 #define ION_MAX 10
2557 static struct ion_handle *ion_hanle[ION_MAX];
2558 static struct ion_handle *ion_hwc[1];
2559 #endif
2560 static int rk_fb_ioctl(struct fb_info *info, unsigned int cmd,
2561                        unsigned long arg)
2562 {
2563         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
2564         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2565         struct rk_fb_par *extend_fb_par = NULL;
2566         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2567         struct fb_fix_screeninfo *fix = &info->fix;
2568         int fb_id = 0, extend_win_id = 0;
2569         struct fb_info *extend_info = NULL;
2570         struct rk_lcdc_driver *extend_dev_drv = NULL;
2571         struct rk_lcdc_win *extend_win = NULL;
2572         struct rk_lcdc_win *win;
2573         int enable;     /* enable fb:1 enable;0 disable */
2574         int ovl;        /* overlay:0 win1 on the top of win0;1,win0 on the top of win1 */
2575         int num_buf;    /* buffer_number */
2576         int ret;
2577         struct rk_fb_win_cfg_data win_data;
2578         unsigned int dsp_addr[4];
2579         int list_stat;
2580
2581         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
2582
2583         void __user *argp = (void __user *)arg;
2584         win = dev_drv->win[win_id];
2585         if (rk_fb->disp_mode == DUAL) {
2586                 fb_id = get_extend_fb_id(info);
2587                 extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
2588                 extend_fb_par = (struct rk_fb_par *)extend_info->par;
2589                 extend_dev_drv = extend_fb_par->lcdc_drv;
2590                 extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
2591                                                             extend_info->fix.id);
2592                 extend_win = extend_dev_drv->win[extend_win_id];
2593         }
2594
2595         switch (cmd) {
2596         case RK_FBIOSET_HWC_ADDR:
2597         {
2598                 u32 hwc_phy[1];
2599                 if (copy_from_user(hwc_phy, argp, 4))
2600                         return -EFAULT;
2601 #ifdef CONFIG_ROCKCHIP_IOMMU
2602                 if (!dev_drv->iommu_enabled) {
2603 #endif
2604                         fix->smem_start = hwc_phy[0];
2605 #ifdef CONFIG_ROCKCHIP_IOMMU
2606                 } else {
2607                         int usr_fd;
2608                         struct ion_handle *hdl;
2609                         ion_phys_addr_t phy_addr;
2610                         size_t len;
2611
2612                         usr_fd = hwc_phy[0];
2613                         if (!usr_fd) {
2614                                 fix->smem_start = 0;
2615                                 fix->mmio_start = 0;
2616                                 break;
2617                         }
2618
2619                         if (ion_hwc[0] != 0) {
2620                                 ion_free(rk_fb->ion_client, ion_hwc[0]);
2621                                 ion_hwc[0] = 0;
2622                         }
2623
2624                         hdl = ion_import_dma_buf(rk_fb->ion_client, usr_fd);
2625                         if (IS_ERR(hdl)) {
2626                                 dev_err(info->dev, "failed to get hwc ion handle:%ld\n",
2627                                         PTR_ERR(hdl));
2628                                 return -EFAULT;
2629                         }
2630
2631                         ret = ion_map_iommu(dev_drv->dev, rk_fb->ion_client, hdl,
2632                                                 (unsigned long *)&phy_addr,
2633                                                 (unsigned long *)&len);
2634                         if (ret < 0) {
2635                                 dev_err(info->dev, "ion map to get hwc phy addr failed");
2636                                 ion_free(rk_fb->ion_client, hdl);
2637                                 return -ENOMEM;
2638                         }
2639                         fix->smem_start = phy_addr;
2640                         ion_hwc[0] = hdl;
2641                 }
2642 #endif
2643                 break;
2644         }
2645         case RK_FBIOSET_YUV_ADDR:
2646                 {
2647                         u32 yuv_phy[2];
2648
2649                         if (copy_from_user(yuv_phy, argp, 8))
2650                                 return -EFAULT;
2651                         #ifdef CONFIG_ROCKCHIP_IOMMU
2652                         if (!dev_drv->iommu_enabled || !strcmp(info->fix.id, "fb0")) {
2653                         #endif
2654                                 fix->smem_start = yuv_phy[0];
2655                                 fix->mmio_start = yuv_phy[1];
2656                         #ifdef CONFIG_ROCKCHIP_IOMMU
2657                         } else {
2658                                 int usr_fd, offset, tmp;
2659                                 struct ion_handle *hdl;
2660                                 ion_phys_addr_t phy_addr;
2661                                 size_t len;
2662
2663                                 usr_fd = yuv_phy[0];
2664                                 offset = yuv_phy[1] - yuv_phy[0];
2665
2666                                 if (!usr_fd) {
2667                                         fix->smem_start = 0;
2668                                         fix->mmio_start = 0;
2669                                         break;
2670                                 }
2671
2672                                 if (ion_hanle[ION_MAX - 1] != 0) {
2673                                         /*ion_unmap_kernel(rk_fb->ion_client, ion_hanle[ION_MAX - 1]);*/
2674                                         /*ion_unmap_iommu(dev_drv->dev, rk_fb->ion_client, ion_hanle[ION_MAX - 1]);*/
2675                                         ion_free(rk_fb->ion_client, ion_hanle[ION_MAX - 1]);
2676                                         ion_hanle[ION_MAX - 1] = 0;
2677                                 }
2678
2679                                 hdl = ion_import_dma_buf(rk_fb->ion_client, usr_fd);
2680                                 if (IS_ERR(hdl)) {
2681                                         dev_err(info->dev, "failed to get ion handle:%ld\n",
2682                                                 PTR_ERR(hdl));
2683                                         return -EFAULT;
2684                                 }
2685
2686                                 ret = ion_map_iommu(dev_drv->dev, rk_fb->ion_client, hdl,
2687                                                         (unsigned long *)&phy_addr,
2688                                                         (unsigned long *)&len);
2689                                 if (ret < 0) {
2690                                         dev_err(info->dev, "ion map to get phy addr failed");
2691                                         ion_free(rk_fb->ion_client, hdl);
2692                                         return -ENOMEM;
2693                                 }
2694                                 fix->smem_start = phy_addr;
2695                                 fix->mmio_start = phy_addr + offset;
2696                                 fix->smem_len = len;
2697                                 /*info->screen_base = ion_map_kernel(rk_fb->ion_client, hdl);*/
2698
2699                                 ion_hanle[0] = hdl;
2700                                 for (tmp = ION_MAX - 1; tmp > 0; tmp--)
2701                                         ion_hanle[tmp] = ion_hanle[tmp - 1];
2702                                 ion_hanle[0] = 0;
2703                         }
2704                         #endif
2705                         break;
2706                 }
2707         case RK_FBIOSET_ENABLE:
2708                 if (copy_from_user(&enable, argp, sizeof(enable)))
2709                         return -EFAULT;
2710                                 if (enable)
2711                                         fb_par->state++;
2712                                 else
2713                                         fb_par->state--;
2714                 dev_drv->ops->open(dev_drv, win_id, enable);
2715                 break;
2716         case RK_FBIOGET_ENABLE:
2717                 enable = dev_drv->ops->get_win_state(dev_drv, win_id);
2718                 if (copy_to_user(argp, &enable, sizeof(enable)))
2719                         return -EFAULT;
2720                 break;
2721         case RK_FBIOSET_OVERLAY_STA:
2722                 if (copy_from_user(&ovl, argp, sizeof(ovl)))
2723                         return -EFAULT;
2724                 dev_drv->ops->ovl_mgr(dev_drv, ovl, 1);
2725                 break;
2726         case RK_FBIOGET_OVERLAY_STA:
2727                 ovl = dev_drv->ops->ovl_mgr(dev_drv, 0, 0);
2728                 if (copy_to_user(argp, &ovl, sizeof(ovl)))
2729                         return -EFAULT;
2730                 break;
2731         case RK_FBIOPUT_NUM_BUFFERS:
2732                 if (copy_from_user(&num_buf, argp, sizeof(num_buf)))
2733                         return -EFAULT;
2734                 dev_drv->num_buf = num_buf;
2735                 break;
2736         case RK_FBIOSET_VSYNC_ENABLE:
2737                 if (copy_from_user(&enable, argp, sizeof(enable)))
2738                         return -EFAULT;
2739                 dev_drv->vsync_info.active = enable;
2740                 break;
2741
2742         case RK_FBIOGET_DSP_ADDR:
2743                 dev_drv->ops->get_dsp_addr(dev_drv, dsp_addr);
2744                 if (copy_to_user(argp, &dsp_addr, sizeof(dsp_addr)))
2745                         return -EFAULT;
2746                 break;
2747         case RK_FBIOGET_LIST_STA:
2748                 list_stat = rk_fb_get_list_stat(dev_drv);
2749                 if (copy_to_user(argp, &list_stat, sizeof(list_stat)))
2750                         return -EFAULT;
2751
2752                 break;
2753         case RK_FBIOGET_IOMMU_STA:
2754                 if (copy_to_user(argp, &dev_drv->iommu_enabled,
2755                                  sizeof(dev_drv->iommu_enabled)))
2756                         return -EFAULT;
2757                 break;
2758 #if defined(CONFIG_ION_ROCKCHIP)
2759         case RK_FBIOSET_DMABUF_FD:
2760                 {
2761                         int usr_fd;
2762                         struct ion_handle *hdl;
2763                         ion_phys_addr_t phy_addr;
2764                         size_t len;
2765                         if (copy_from_user(&usr_fd, argp, sizeof(usr_fd)))
2766                                 return -EFAULT;
2767                         hdl = ion_import_dma_buf(rk_fb->ion_client, usr_fd);
2768                         ion_phys(rk_fb->ion_client, hdl, &phy_addr, &len);
2769                         fix->smem_start = phy_addr;
2770                         break;
2771                 }
2772         case RK_FBIOGET_DMABUF_FD:
2773                 {
2774                         int fd = -1;
2775
2776                         if (IS_ERR_OR_NULL(fb_par->ion_hdl)) {
2777                                 dev_err(info->dev,
2778                                         "get dma_buf fd failed,ion handle is err\n");
2779                                 return PTR_ERR(fb_par->ion_hdl);
2780                         }
2781                         fd = ion_share_dma_buf_fd(rk_fb->ion_client,
2782                                                   fb_par->ion_hdl);
2783                         if (fd < 0) {
2784                                 dev_err(info->dev,
2785                                         "ion_share_dma_buf_fd failed\n");
2786                                 return fd;
2787                         }
2788                         if (copy_to_user(argp, &fd, sizeof(fd)))
2789                                 return -EFAULT;
2790                         break;
2791                 }
2792 #endif
2793         case RK_FBIOSET_CLEAR_FB:
2794                 memset(fb_par->fb_virt_base, 0, fb_par->fb_size);
2795                 break;
2796         case RK_FBIOSET_CONFIG_DONE:
2797                 {
2798                         int curr = 0;
2799                         struct timespec now;
2800
2801                         getnstimeofday(&now);
2802                         curr = now.tv_sec * 1000000 + now.tv_nsec / 1000;
2803                         cfgdone_distlist[cfgdone_index++] =
2804                             curr - cfgdone_lasttime;
2805                         /*
2806                            printk("%d ", curr - cfgdone_lasttime);
2807                          */
2808                         cfgdone_lasttime = curr;
2809                         if (cfgdone_index >= 10)
2810                                 cfgdone_index = 0;
2811                 }
2812                 if (copy_from_user(&win_data,
2813                                    (struct rk_fb_win_cfg_data __user *)argp,
2814                                    sizeof(win_data))) {
2815                         ret = -EFAULT;
2816                         break;
2817                 };
2818
2819                 dev_drv->wait_fs = win_data.wait_fs;
2820                 rk_fb_set_win_config(info, &win_data);
2821
2822                 if (copy_to_user((struct rk_fb_win_cfg_data __user *)arg,
2823                                  &win_data, sizeof(win_data))) {
2824                         ret = -EFAULT;
2825                         break;
2826                 }
2827                 memset(&win_data, 0, sizeof(struct rk_fb_win_cfg_data));
2828                 break;
2829         default:
2830                 dev_drv->ops->ioctl(dev_drv, cmd, arg, win_id);
2831                 break;
2832         }
2833
2834         return 0;
2835 }
2836
2837 static int rk_fb_blank(int blank_mode, struct fb_info *info)
2838 {
2839         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2840         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2841         struct fb_fix_screeninfo *fix = &info->fix;
2842         int win_id;
2843 #if defined(CONFIG_RK_HDMI)
2844         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
2845 #endif
2846
2847         win_id = dev_drv->ops->fb_get_win_id(dev_drv, fix->id);
2848         if (win_id < 0)
2849                 return -ENODEV;
2850 #if defined(CONFIG_RK_HDMI)
2851         if ((rk_fb->disp_mode == ONE_DUAL) &&
2852             (hdmi_get_hotplug() == HDMI_HPD_ACTIVED)) {
2853                 printk(KERN_INFO "hdmi is connect , not blank lcdc\n");
2854         } else
2855 #endif
2856         {
2857                 dev_drv->ops->blank(dev_drv, win_id, blank_mode);
2858         }
2859         return 0;
2860 }
2861
2862 static int rk_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
2863 {
2864         if ((0 == var->xres_virtual) || (0 == var->yres_virtual) ||
2865             (0 == var->xres) || (0 == var->yres) || (var->xres < 16) ||
2866             ((16 != var->bits_per_pixel) &&
2867             (32 != var->bits_per_pixel) &&
2868             (24 != var->bits_per_pixel))) {
2869                 dev_err(info->dev, "%s check var fail 1:\n"
2870                         "xres_vir:%d>>yres_vir:%d\n"
2871                         "xres:%d>>yres:%d\n"
2872                         "bits_per_pixel:%d\n",
2873                         info->fix.id,
2874                         var->xres_virtual,
2875                         var->yres_virtual,
2876                         var->xres, var->yres, var->bits_per_pixel);
2877                 return -EINVAL;
2878         }
2879
2880         if (((var->xoffset + var->xres) > var->xres_virtual) ||
2881             ((var->yoffset + var->yres) > (var->yres_virtual))) {
2882                 dev_err(info->dev, "%s check_var fail 2:\n"
2883                         "xoffset:%d>>xres:%d>>xres_vir:%d\n"
2884                         "yoffset:%d>>yres:%d>>yres_vir:%d\n",
2885                         info->fix.id,
2886                         var->xoffset,
2887                         var->xres,
2888                         var->xres_virtual,
2889                         var->yoffset, var->yres, var->yres_virtual);
2890                 return -EINVAL;
2891         }
2892
2893         return 0;
2894 }
2895
2896 static ssize_t rk_fb_read(struct fb_info *info, char __user *buf,
2897                           size_t count, loff_t *ppos)
2898 {
2899         unsigned long p = *ppos;
2900         u8 *buffer, *dst;
2901         u8 __iomem *src;
2902         int c, cnt = 0, err = 0;
2903         unsigned long total_size;
2904         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2905         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2906         struct rk_lcdc_win *win = NULL;
2907         int win_id = 0;
2908
2909         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
2910         if (win_id < 0)
2911                 return -ENODEV;
2912         else
2913                 win = dev_drv->win[win_id];
2914
2915         /* only read the current frame buffer */
2916         if (win->format == RGB565) {
2917                 total_size = win->area[0].y_vir_stride * win->area[0].yact << 1;
2918         } else if (win->format == YUV420) {
2919                 total_size =
2920                     (win->area[0].y_vir_stride * win->area[0].yact * 6);
2921         } else {
2922                 total_size = win->area[0].y_vir_stride * win->area[0].yact << 2;
2923         }
2924         if (p >= total_size)
2925                 return 0;
2926
2927         if (count >= total_size)
2928                 count = total_size;
2929
2930         if (count + p > total_size)
2931                 count = total_size - p;
2932
2933         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
2934         if (!buffer)
2935                 return -ENOMEM;
2936
2937         src = (u8 __iomem *)(info->screen_base + p + win->area[0].y_offset);
2938
2939         while (count) {
2940                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
2941                 dst = buffer;
2942                 fb_memcpy_fromfb(dst, src, c);
2943                 dst += c;
2944                 src += c;
2945
2946                 if (copy_to_user(buf, buffer, c)) {
2947                         err = -EFAULT;
2948                         break;
2949                 }
2950                 *ppos += c;
2951                 buf += c;
2952                 cnt += c;
2953                 count -= c;
2954         }
2955
2956         kfree(buffer);
2957
2958         return (err) ? err : cnt;
2959 }
2960
2961 static ssize_t rk_fb_write(struct fb_info *info, const char __user *buf,
2962                            size_t count, loff_t *ppos)
2963 {
2964         unsigned long p = *ppos;
2965         u8 *buffer, *src;
2966         u8 __iomem *dst;
2967         int c, cnt = 0, err = 0;
2968         unsigned long total_size;
2969         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
2970         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
2971         struct rk_lcdc_win *win = NULL;
2972         int win_id = 0;
2973
2974         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
2975         if (win_id < 0)
2976                 return -ENODEV;
2977         else
2978                 win = dev_drv->win[win_id];
2979
2980         /* write the current frame buffer */
2981         if (win->format == RGB565)
2982                 total_size = win->area[0].xact * win->area[0].yact << 1;
2983         else
2984                 total_size = win->area[0].xact * win->area[0].yact << 2;
2985
2986         if (p > total_size)
2987                 return -EFBIG;
2988
2989         if (count > total_size) {
2990                 err = -EFBIG;
2991                 count = total_size;
2992         }
2993
2994         if (count + p > total_size) {
2995                 if (!err)
2996                         err = -ENOSPC;
2997
2998                 count = total_size - p;
2999         }
3000
3001         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
3002         if (!buffer)
3003                 return -ENOMEM;
3004
3005         dst = (u8 __iomem *)(info->screen_base + p + win->area[0].y_offset);
3006
3007         while (count) {
3008                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
3009                 src = buffer;
3010
3011                 if (copy_from_user(src, buf, c)) {
3012                         err = -EFAULT;
3013                         break;
3014                 }
3015
3016                 fb_memcpy_tofb(dst, src, c);
3017                 dst += c;
3018                 src += c;
3019                 *ppos += c;
3020                 buf += c;
3021                 cnt += c;
3022                 count -= c;
3023         }
3024
3025         kfree(buffer);
3026
3027         return (cnt) ? cnt : err;
3028 }
3029
3030 /*
3031  * function: update extend info acorrding to primary info that only used for dual display mode
3032  * @ext_info: the fb_info of extend screen
3033  * @info: the fb_info of primary screen
3034  * @update_buffer: whether to update extend info buffer, 0: no;1: yes
3035  */
3036 static int rk_fb_update_ext_info(struct fb_info *ext_info,
3037                                         struct fb_info *info, int update_buffer)
3038 {
3039         struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
3040         struct rk_fb_par *fb_par = NULL;
3041         struct rk_fb_par *ext_fb_par = NULL;
3042         struct rk_lcdc_driver *dev_drv = NULL;
3043         struct rk_lcdc_driver *ext_dev_drv = NULL;
3044         struct rk_lcdc_win *win = NULL;
3045         struct rk_lcdc_win *ext_win = NULL;
3046         int win_id = 0, ext_win_id = 0;
3047
3048         if (rk_fb->disp_mode != DUAL || info == ext_info)
3049                 return 0;
3050         if (unlikely(!info) || unlikely(!ext_info))
3051                 return -1;
3052
3053         fb_par = (struct rk_fb_par *)info->par;
3054         ext_fb_par = (struct rk_fb_par *)ext_info->par;
3055         dev_drv = fb_par->lcdc_drv;
3056         ext_dev_drv = ext_fb_par->lcdc_drv;
3057         if (unlikely(!dev_drv) || unlikely(!ext_dev_drv))
3058                 return -1;
3059
3060         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
3061         win = dev_drv->win[win_id];
3062         ext_win_id = ext_dev_drv->ops->fb_get_win_id(ext_dev_drv,
3063                                                      ext_info->fix.id);
3064         ext_win = ext_dev_drv->win[ext_win_id];
3065
3066         rk_fb_update_ext_win(ext_dev_drv, dev_drv, ext_win, win);
3067         if (update_buffer) {
3068                 rk_fb_set_ext_win_buffer(ext_win, win, ext_dev_drv->rotate_mode,
3069                                          ext_dev_drv->iommu_enabled);
3070
3071                 /* update extend info display address */
3072                 ext_info->fix.smem_start = ext_win->area[0].smem_start;
3073                 ext_info->fix.mmio_start = ext_win->area[0].cbr_start;
3074
3075                 if (ext_dev_drv->rotate_mode > X_Y_MIRROR)
3076                         rk_fb_rotate(ext_info, info);
3077         }
3078
3079         /* update extend info */
3080         ext_info->var.xres = ext_win->area[0].xact;
3081         ext_info->var.yres = ext_win->area[0].yact;
3082         ext_info->var.xres_virtual = ext_win->area[0].xvir;
3083         ext_info->var.yres_virtual = ext_win->area[0].yvir;
3084
3085         /* config same data format */
3086         ext_info->var.nonstd &= 0xffffff00;
3087         ext_info->var.nonstd |= (info->var.nonstd & 0xff);
3088
3089         ext_info->var.nonstd &= 0xff;
3090         ext_info->var.nonstd |=
3091                 (ext_win->area[0].xpos << 8) + (ext_win->area[0].ypos << 20);
3092
3093         ext_info->var.grayscale &= 0xff;
3094         ext_info->var.grayscale |=
3095                 (ext_win->area[0].xsize << 8) + (ext_win->area[0].ysize << 20);
3096
3097         return 0;
3098 }
3099
3100 static int rk_fb_set_par(struct fb_info *info)
3101 {
3102         struct fb_var_screeninfo *var = &info->var;
3103         struct fb_fix_screeninfo *fix = &info->fix;
3104         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
3105         struct rk_fb_par *extend_fb_par = NULL;
3106         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3107         struct rk_fb *rk_fb = dev_get_drvdata(info->device);
3108         int fb_id, extend_win_id = 0;
3109         struct fb_info *extend_info = NULL;
3110         struct rk_lcdc_driver *extend_dev_drv = NULL;
3111         struct rk_lcdc_win *extend_win = NULL;
3112         struct rk_lcdc_win *win = NULL;
3113         struct rk_screen *screen = dev_drv->cur_screen;
3114         int win_id = 0;
3115         u32 cblen = 0, crlen = 0;
3116         u16 xsize = 0, ysize = 0;       /* winx display window height/width --->LCDC_WINx_DSP_INFO */
3117         u32 xoffset = var->xoffset;     /* offset from virtual to visible */
3118         u32 yoffset = var->yoffset;
3119         u16 xpos = (var->nonstd >> 8) & 0xfff;  /*visiable pos in panel */
3120         u16 ypos = (var->nonstd >> 20) & 0xfff;
3121         u32 xvir = var->xres_virtual;
3122         u32 yvir = var->yres_virtual;
3123         u8 data_format = var->nonstd & 0xff;
3124         u8 fb_data_fmt;
3125         u8 pixel_width;
3126         u32 vir_width_bit;
3127         u32 stride, uv_stride;
3128         u32 stride_32bit_1;
3129         u32 stride_32bit_2;
3130         u16 uv_x_off, uv_y_off, uv_y_act;
3131         u8 is_pic_yuv = 0;
3132
3133         var->pixclock = dev_drv->pixclock;
3134         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
3135         if (win_id < 0)
3136                 return -ENODEV;
3137         else
3138                 win = dev_drv->win[win_id];
3139
3140         if (rk_fb->disp_mode == DUAL) {
3141                 fb_id = get_extend_fb_id(info);
3142                 extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
3143                 extend_fb_par = (struct rk_fb_par *)extend_info->par;
3144                 extend_dev_drv = extend_fb_par->lcdc_drv;
3145                 extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
3146                                                             extend_info->fix.id);
3147                 extend_win = extend_dev_drv->win[extend_win_id];
3148         }
3149
3150         /* if the application has specific the horizontal and vertical display size */
3151         if (var->grayscale >> 8) {
3152                 xsize = (var->grayscale >> 8) & 0xfff;
3153                 ysize = (var->grayscale >> 20) & 0xfff;
3154                 if (xsize > screen->mode.xres)
3155                         xsize = screen->mode.xres;
3156                 if (ysize > screen->mode.yres)
3157                         ysize = screen->mode.yres;
3158         } else {                /*ohterwise  full  screen display */
3159                 xsize = screen->mode.xres;
3160                 ysize = screen->mode.yres;
3161         }
3162
3163         fb_data_fmt = rk_fb_data_fmt(data_format, var->bits_per_pixel);
3164         pixel_width = rk_fb_pixel_width(fb_data_fmt);
3165         vir_width_bit = pixel_width * xvir;
3166         /* pixel_width = byte_num * 8 */
3167         stride_32bit_1 = ALIGN_N_TIMES(vir_width_bit, 32) / 8;
3168         stride_32bit_2 = ALIGN_N_TIMES(vir_width_bit * 2, 32) / 8;
3169
3170         switch (fb_data_fmt) {
3171         case YUV422:
3172         case YUV422_A:
3173                 is_pic_yuv = 1;
3174                 stride = stride_32bit_1;
3175                 uv_stride = stride_32bit_1 >> 1;
3176                 uv_x_off = xoffset >> 1;
3177                 uv_y_off = yoffset;
3178                 fix->line_length = stride;
3179                 cblen = crlen = (xvir * yvir) >> 1;
3180                 uv_y_act = win->area[0].yact >> 1;
3181                 break;
3182         case YUV420:            /* 420sp */
3183         case YUV420_A:
3184                 is_pic_yuv = 1;
3185                 stride = stride_32bit_1;
3186                 uv_stride = stride_32bit_1;
3187                 uv_x_off = xoffset;
3188                 uv_y_off = yoffset >> 1;
3189                 fix->line_length = stride;
3190                 cblen = crlen = (xvir * yvir) >> 2;
3191                 uv_y_act = win->area[0].yact >> 1;
3192                 break;
3193         case YUV444:
3194         case YUV444_A:
3195                 is_pic_yuv = 1;
3196                 stride = stride_32bit_1;
3197                 uv_stride = stride_32bit_2;
3198                 uv_x_off = xoffset * 2;
3199                 uv_y_off = yoffset;
3200                 fix->line_length = stride << 2;
3201                 cblen = crlen = (xvir * yvir);
3202                 uv_y_act = win->area[0].yact;
3203                 break;
3204         default:
3205                 stride = stride_32bit_1;        /* default rgb */
3206                 fix->line_length = stride;
3207                 break;
3208         }
3209
3210         /* x y mirror ,jump line */
3211         if (screen->y_mirror == 1) {
3212                 if (screen->interlace == 1) {
3213                         win->area[0].y_offset = yoffset * stride * 2 +
3214                             ((win->area[0].yact - 1) * 2 + 1) * stride +
3215                             xoffset * pixel_width / 8;
3216                 } else {
3217                         win->area[0].y_offset = yoffset * stride +
3218                             (win->area[0].yact - 1) * stride +
3219                             xoffset * pixel_width / 8;
3220                 }
3221         } else {
3222                 if (screen->interlace == 1) {
3223                         win->area[0].y_offset =
3224                             yoffset * stride * 2 + xoffset * pixel_width / 8;
3225                 } else {
3226                         win->area[0].y_offset =
3227                             yoffset * stride + xoffset * pixel_width / 8;
3228                 }
3229         }
3230         if (is_pic_yuv == 1) {
3231                 if (screen->y_mirror == 1) {
3232                         if (screen->interlace == 1) {
3233                                 win->area[0].c_offset =
3234                                     uv_y_off * uv_stride * 2 +
3235                                     ((uv_y_act - 1) * 2 + 1) * uv_stride +
3236                                     uv_x_off * pixel_width / 8;
3237                         } else {
3238                                 win->area[0].c_offset = uv_y_off * uv_stride +
3239                                     (uv_y_act - 1) * uv_stride +
3240                                     uv_x_off * pixel_width / 8;
3241                         }
3242                 } else {
3243                         if (screen->interlace == 1) {
3244                                 win->area[0].c_offset =
3245                                     uv_y_off * uv_stride * 2 +
3246                                     uv_x_off * pixel_width / 8;
3247                         } else {
3248                                 win->area[0].c_offset =
3249                                     uv_y_off * uv_stride +
3250                                     uv_x_off * pixel_width / 8;
3251                         }
3252                 }
3253         }
3254
3255         win->format = fb_data_fmt;
3256         win->area[0].y_vir_stride = stride >> 2;
3257         win->area[0].uv_vir_stride = uv_stride >> 2;
3258         win->area[0].xpos = xpos;
3259         win->area[0].ypos = ypos;
3260         win->area[0].xsize = xsize;
3261         win->area[0].ysize = ysize;
3262         win->area[0].xact = var->xres;  /* winx active window height,is a wint of vir */
3263         win->area[0].yact = var->yres;
3264         win->area[0].xvir = var->xres_virtual;  /* virtual resolution  stride --->LCDC_WINx_VIR */
3265         win->area[0].yvir = var->yres_virtual;
3266
3267         win->area_num = 1;
3268         win->alpha_mode = 4;    /* AB_SRC_OVER; */
3269         win->alpha_en = ((win->format == ARGB888) ||
3270                          (win->format == ABGR888)) ? 1 : 0;
3271         win->g_alpha_val = 0;
3272
3273         if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
3274             (win->format == YUV420 || win->format == YUV420_A))
3275             win->state = 1;
3276         if (rk_fb->disp_mode == DUAL) {
3277                 if (extend_win->state && hdmi_switch_complete) {
3278                         if (info != extend_info) {
3279                                 rk_fb_update_ext_win(extend_dev_drv, dev_drv,
3280                                                      extend_win, win);
3281                                 extend_dev_drv->ops->set_par(extend_dev_drv,
3282                                                              extend_win_id);
3283                         }
3284                 }
3285         }
3286         dev_drv->ops->set_par(dev_drv, win_id);
3287
3288         return 0;
3289 }
3290
3291 static inline unsigned int chan_to_field(unsigned int chan,
3292                                          struct fb_bitfield *bf)
3293 {
3294         chan &= 0xffff;
3295         chan >>= 16 - bf->length;
3296         return chan << bf->offset;
3297 }
3298
3299 static int fb_setcolreg(unsigned regno,
3300                         unsigned red, unsigned green, unsigned blue,
3301                         unsigned transp, struct fb_info *info)
3302 {
3303         unsigned int val;
3304
3305         switch (info->fix.visual) {
3306         case FB_VISUAL_TRUECOLOR:
3307                 /* true-colour, use pseudo-palette */
3308                 if (regno < 16) {
3309                         u32 *pal = info->pseudo_palette;
3310                         val = chan_to_field(red, &info->var.red);
3311                         val |= chan_to_field(green, &info->var.green);
3312                         val |= chan_to_field(blue, &info->var.blue);
3313                         pal[regno] = val;
3314                 }
3315                 break;
3316         default:
3317                 return -1;      /* unknown type */
3318         }
3319
3320         return 0;
3321 }
3322
3323 static int rk_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
3324 {
3325         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3326         struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
3327         struct ion_handle *handle = fb_par->ion_hdl;
3328         struct dma_buf *dma_buf = NULL;
3329
3330         if (IS_ERR_OR_NULL(handle)) {
3331                 dev_err(info->dev, "failed to get ion handle:%ld\n",
3332                         PTR_ERR(handle));
3333                 return -ENOMEM;
3334         }
3335         dma_buf = ion_share_dma_buf(rk_fb->ion_client, handle);
3336         if (IS_ERR_OR_NULL(dma_buf)) {
3337                 printk("get ion share dma buf failed\n");
3338                 return -ENOMEM;
3339         }
3340
3341         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
3342
3343         return dma_buf_mmap(dma_buf, vma, 0);
3344 }
3345
3346 static struct fb_ops fb_ops = {
3347         .owner = THIS_MODULE,
3348         .fb_open = rk_fb_open,
3349         .fb_release = rk_fb_close,
3350         .fb_check_var = rk_fb_check_var,
3351         .fb_set_par = rk_fb_set_par,
3352         .fb_blank = rk_fb_blank,
3353         .fb_ioctl = rk_fb_ioctl,
3354         .fb_pan_display = rk_fb_pan_display,
3355         .fb_read = rk_fb_read,
3356         .fb_write = rk_fb_write,
3357         .fb_setcolreg = fb_setcolreg,
3358         .fb_fillrect = cfb_fillrect,
3359         .fb_copyarea = cfb_copyarea,
3360         .fb_imageblit = cfb_imageblit,
3361 };
3362
3363 static struct fb_var_screeninfo def_var = {
3364 #if defined(CONFIG_LOGO_LINUX_BMP)
3365         .red = {16, 8, 0},
3366         .green = {8, 8, 0},
3367         .blue = {0, 8, 0},
3368         .transp = {0, 0, 0},
3369         .nonstd = HAL_PIXEL_FORMAT_BGRA_8888,
3370 #else
3371         .red = {11, 5, 0},
3372         .green = {5, 6, 0},
3373         .blue = {0, 5, 0},
3374         .transp = {0, 0, 0},
3375         .nonstd = HAL_PIXEL_FORMAT_RGB_565,     /* (ypos<<20+xpos<<8+format) format */
3376 #endif
3377         .grayscale = 0,         /* (ysize<<20+xsize<<8) */
3378         .activate = FB_ACTIVATE_NOW,
3379         .accel_flags = 0,
3380         .vmode = FB_VMODE_NONINTERLACED,
3381 };
3382
3383 static struct fb_fix_screeninfo def_fix = {
3384         .type = FB_TYPE_PACKED_PIXELS,
3385         .type_aux = 0,
3386         .xpanstep = 1,
3387         .ypanstep = 1,
3388         .ywrapstep = 0,
3389         .accel = FB_ACCEL_NONE,
3390         .visual = FB_VISUAL_TRUECOLOR,
3391
3392 };
3393
3394 static int rk_fb_wait_for_vsync_thread(void *data)
3395 {
3396         struct rk_lcdc_driver *dev_drv = data;
3397         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3398         struct fb_info *fbi = rk_fb->fb[0];
3399
3400         while (!kthread_should_stop()) {
3401                 ktime_t timestamp = dev_drv->vsync_info.timestamp;
3402                 int ret = wait_event_interruptible(dev_drv->vsync_info.wait,
3403                                 !ktime_equal(timestamp, dev_drv->vsync_info.timestamp) &&
3404                                 (dev_drv->vsync_info.active || dev_drv->vsync_info.irq_stop));
3405
3406                 if (!ret)
3407                         sysfs_notify(&fbi->dev->kobj, NULL, "vsync");
3408         }
3409
3410         return 0;
3411 }
3412
3413 static ssize_t rk_fb_vsync_show(struct device *dev,
3414                                 struct device_attribute *attr, char *buf)
3415 {
3416         struct fb_info *fbi = dev_get_drvdata(dev);
3417         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
3418         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3419         return scnprintf(buf, PAGE_SIZE, "%llu\n",
3420                          ktime_to_ns(dev_drv->vsync_info.timestamp));
3421 }
3422
3423 static DEVICE_ATTR(vsync, S_IRUGO, rk_fb_vsync_show, NULL);
3424
3425 /*
3426  * this two function is for other module that in the kernel which
3427  * need show image directly through fb
3428  * fb_id:we have 4 fb here,default we use fb0 for ui display
3429  */
3430 struct fb_info *rk_get_fb(int fb_id)
3431 {
3432         struct rk_fb *inf = platform_get_drvdata(fb_pdev);
3433         struct fb_info *fb = inf->fb[fb_id];
3434         return fb;
3435 }
3436 EXPORT_SYMBOL(rk_get_fb);
3437
3438 void rk_direct_fb_show(struct fb_info *fbi)
3439 {
3440         rk_fb_set_par(fbi);
3441         rk_fb_pan_display(&fbi->var, fbi);
3442 }
3443 EXPORT_SYMBOL(rk_direct_fb_show);
3444
3445 int rk_fb_dpi_open(bool open)
3446 {
3447         struct rk_lcdc_driver *dev_drv = NULL;
3448         dev_drv = rk_get_prmry_lcdc_drv();
3449
3450         if (dev_drv->ops->dpi_open)
3451                 dev_drv->ops->dpi_open(dev_drv, open);
3452         return 0;
3453 }
3454
3455 int rk_fb_dpi_win_sel(int win_id)
3456 {
3457         struct rk_lcdc_driver *dev_drv = NULL;
3458         dev_drv = rk_get_prmry_lcdc_drv();
3459
3460         if (dev_drv->ops->dpi_win_sel)
3461                 dev_drv->ops->dpi_win_sel(dev_drv, win_id);
3462         return 0;
3463 }
3464
3465 int rk_fb_dpi_status(void)
3466 {
3467         int ret = 0;
3468         struct rk_lcdc_driver *dev_drv = NULL;
3469
3470         dev_drv = rk_get_prmry_lcdc_drv();
3471         if (dev_drv->ops->dpi_status)
3472                 ret = dev_drv->ops->dpi_status(dev_drv);
3473
3474         return ret;
3475 }
3476
3477 /*
3478  * function: this function will be called by display device, enable/disable lcdc
3479  * @screen: screen timing to be set to lcdc
3480  * @enable: 0 disable lcdc; 1 enable change lcdc timing; 2 just enable dclk
3481  * @lcdc_id: the lcdc id the display device attached ,0 or 1
3482  */
3483 int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
3484 {
3485         struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
3486         struct fb_info *info = NULL;
3487         struct fb_info *pmy_info = NULL;
3488         struct rk_fb_par *fb_par = NULL;
3489         struct rk_fb_par *pmy_fb_par = NULL;
3490         struct rk_lcdc_driver *dev_drv = NULL;
3491         char name[6] = {0};
3492         int i, win_id, load_screen = 0;
3493
3494         if (unlikely(!rk_fb) || unlikely(!screen))
3495                 return -ENODEV;
3496
3497         hdmi_switch_complete = 0;
3498         /* get lcdc driver */
3499         sprintf(name, "lcdc%d", lcdc_id);
3500         if (rk_fb->disp_mode != DUAL)
3501                 dev_drv = rk_fb->lcdc_dev_drv[0];
3502         else
3503                 dev_drv = rk_get_lcdc_drv(name);
3504
3505         if (dev_drv == NULL) {
3506                 printk(KERN_ERR "%s driver not found!", name);
3507                 return -ENODEV;
3508         }
3509         if (screen->type == SCREEN_HDMI)
3510                 printk("hdmi %s lcdc%d\n", enable ? "connect to" : "remove from",
3511                         dev_drv->id);
3512         else if (screen->type == SCREEN_TVOUT ||
3513                      screen->type == SCREEN_TVOUT_TEST )
3514                 printk("cvbs %s lcdc%d\n", enable ? "connect to" : "remove from",
3515                         dev_drv->id);
3516         if (enable == 2 /*&& dev_drv->enable*/)
3517                 return 0;
3518
3519         if (rk_fb->disp_mode == ONE_DUAL) {
3520                 if (dev_drv->ops->dsp_black)
3521                         dev_drv->ops->dsp_black(dev_drv, 1);
3522                 if (dev_drv->ops->set_screen_scaler)
3523                         dev_drv->ops->set_screen_scaler(dev_drv, dev_drv->screen0, 0);
3524         }
3525
3526         if (!enable) {
3527                 /* if screen type is different, we do not disable lcdc. */
3528                 if (dev_drv->cur_screen->type != screen->type)
3529                         return 0;
3530
3531                 /* if used one lcdc to dual disp, no need to close win */
3532                 if (rk_fb->disp_mode == ONE_DUAL) {
3533                         dev_drv->cur_screen = dev_drv->screen0;
3534                         dev_drv->ops->load_screen(dev_drv, 1);
3535
3536                         /* force modify dsp size */
3537                         info = rk_fb->fb[dev_drv->fb_index_base];
3538                         info->var.grayscale &= 0xff;
3539                         info->var.grayscale |=
3540                                 (dev_drv->cur_screen->mode.xres << 8) +
3541                                 (dev_drv->cur_screen->mode.yres << 20);
3542                         info->fbops->fb_set_par(info);
3543                         info->fbops->fb_pan_display(&info->var, info);
3544
3545                         if (dev_drv->ops->dsp_black)
3546                                 dev_drv->ops->dsp_black(dev_drv, 0);
3547                 } else if (rk_fb->num_lcdc > 1) {
3548                         /* If there is more than one lcdc device, we disable
3549                            the layer which attached to this device */
3550                         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3551                                 if (dev_drv->win[i] && dev_drv->win[i]->state)
3552                                         dev_drv->ops->open(dev_drv, i, 0);
3553                         }
3554                 }
3555
3556                 hdmi_switch_complete = 0;
3557                 return 0;
3558         } else {
3559                 if (dev_drv->screen1)
3560                         dev_drv->cur_screen = dev_drv->screen1;
3561                 memcpy(dev_drv->cur_screen, screen, sizeof(struct rk_screen));
3562                 dev_drv->cur_screen->xsize = dev_drv->cur_screen->mode.xres;
3563                 dev_drv->cur_screen->ysize = dev_drv->cur_screen->mode.yres;
3564                 dev_drv->cur_screen->x_mirror = dev_drv->rotate_mode & X_MIRROR;
3565                 dev_drv->cur_screen->y_mirror = dev_drv->rotate_mode & Y_MIRROR;
3566         }
3567         if (!dev_drv->uboot_logo) {
3568                 for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3569                         info = rk_fb->fb[dev_drv->fb_index_base + i];
3570                         fb_par = (struct rk_fb_par *)info->par;
3571                         win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
3572                         if (dev_drv->win[win_id]) {
3573                                 if (rk_fb->disp_mode == DUAL) {
3574                                         pmy_info = rk_fb->fb[i];
3575                                         if (pmy_info != info) {
3576                                                 pmy_fb_par =
3577                                                         (struct rk_fb_par *)pmy_info->par;
3578                                                 fb_par->state = pmy_fb_par->state;
3579                                         }
3580                                 }
3581                                 if (fb_par->state) {
3582                                         if (!dev_drv->win[win_id]->state)
3583                                                 dev_drv->ops->open(dev_drv, win_id, 1);
3584                                         if (!load_screen) {
3585                                                 dev_drv->ops->load_screen(dev_drv, 1);
3586                                                 load_screen = 1;
3587                                         }
3588                                         info->var.activate |= FB_ACTIVATE_FORCE;
3589                                         if (rk_fb->disp_mode == DUAL) {
3590                                                 rk_fb_update_ext_info(info, pmy_info, 1);
3591                                         } else if (rk_fb->disp_mode == ONE_DUAL) {
3592                                                 info->var.grayscale &= 0xff;
3593                                                 info->var.grayscale |=
3594                                                         (dev_drv->cur_screen->xsize << 8) +
3595                                                         (dev_drv->cur_screen->ysize << 20);
3596                                         }
3597                                         info->fbops->fb_set_par(info);
3598                                         info->fbops->fb_pan_display(&info->var, info);
3599                                 }
3600                         }
3601                 }
3602         }else {
3603                 dev_drv->uboot_logo = 0;
3604         }
3605         hdmi_switch_complete = 1;
3606         if (rk_fb->disp_mode == ONE_DUAL) {
3607                 if (dev_drv->ops->set_screen_scaler)
3608                         dev_drv->ops->set_screen_scaler(dev_drv, dev_drv->screen0, 1);
3609                 if (dev_drv->ops->dsp_black)
3610                         dev_drv->ops->dsp_black(dev_drv, 0);
3611         }
3612         return 0;
3613 }
3614
3615 /*
3616  * function:this function current only called by hdmi for
3617  *      scale the display
3618  * scale_x: scale rate of x resolution
3619  * scale_y: scale rate of y resolution
3620  * lcdc_id: the lcdc id the hdmi attached ,0 or 1
3621  */
3622 int rk_fb_disp_scale(u8 scale_x, u8 scale_y, u8 lcdc_id)
3623 {
3624         struct rk_fb *inf = platform_get_drvdata(fb_pdev);
3625         struct fb_info *info = NULL;
3626         struct fb_info *pmy_info = NULL;
3627         struct fb_var_screeninfo *var = NULL;
3628         struct rk_lcdc_driver *dev_drv = NULL;
3629         u16 screen_x, screen_y;
3630         u16 xpos, ypos;
3631         char name[6];
3632         struct rk_screen primary_screen;
3633         rk_fb_get_prmry_screen(&primary_screen);
3634         if (primary_screen.type == SCREEN_HDMI) {
3635                 return 0;
3636         }
3637
3638         sprintf(name, "lcdc%d", lcdc_id);
3639
3640         if (inf->disp_mode == DUAL) {
3641                 dev_drv = rk_get_lcdc_drv(name);
3642                 if (dev_drv == NULL) {
3643                         printk(KERN_ERR "%s driver not found!", name);
3644                         return -ENODEV;
3645                 }
3646         } else {
3647                 dev_drv = inf->lcdc_dev_drv[0];
3648         }
3649
3650         if (inf->num_lcdc == 1) {
3651                 info = inf->fb[0];
3652         } else if (inf->num_lcdc == 2) {
3653                 info = inf->fb[dev_drv->lcdc_win_num];
3654                 pmy_info = inf->fb[0];
3655         }
3656
3657         var = &info->var;
3658         screen_x = dev_drv->cur_screen->mode.xres;
3659         screen_y = dev_drv->cur_screen->mode.yres;
3660
3661         if (inf->disp_mode != DUAL && dev_drv->screen1) {
3662                 dev_drv->cur_screen->xpos =
3663                     (screen_x - screen_x * scale_x / 100) >> 1;
3664                 dev_drv->cur_screen->ypos =
3665                     (screen_y - screen_y * scale_y / 100) >> 1;
3666                 dev_drv->cur_screen->xsize = screen_x * scale_x / 100;
3667                 dev_drv->cur_screen->ysize = screen_y * scale_y / 100;
3668         } else {
3669                 xpos = (screen_x - screen_x * scale_x / 100) >> 1;
3670                 ypos = (screen_y - screen_y * scale_y / 100) >> 1;
3671                 dev_drv->cur_screen->xsize = screen_x * scale_x / 100;
3672                 dev_drv->cur_screen->ysize = screen_y * scale_y / 100;
3673                 if (inf->disp_mode == DUAL) {
3674                         rk_fb_update_ext_info(info, pmy_info, 0);
3675                 } else {
3676                         var->nonstd &= 0xff;
3677                         var->nonstd |= (xpos << 8) + (ypos << 20);
3678                         var->grayscale &= 0xff;
3679                         var->grayscale |=
3680                                 (dev_drv->cur_screen->xsize << 8) +
3681                                 (dev_drv->cur_screen->ysize << 20);
3682                 }
3683         }
3684
3685         info->fbops->fb_set_par(info);
3686         /* info->fbops->fb_ioctl(info, RK_FBIOSET_CONFIG_DONE, 0); */
3687         dev_drv->ops->cfg_done(dev_drv);
3688         return 0;
3689 }
3690
3691 #if defined(CONFIG_ION_ROCKCHIP)
3692 static int rk_fb_alloc_buffer_by_ion(struct fb_info *fbi,
3693                                      struct rk_lcdc_win *win,
3694                                      unsigned long fb_mem_size)
3695 {
3696         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3697         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
3698         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3699         struct ion_handle *handle;
3700         ion_phys_addr_t phy_addr;
3701         size_t len;
3702         int ret = 0;
3703
3704         if (dev_drv->iommu_enabled)
3705                 handle = ion_alloc(rk_fb->ion_client, (size_t) fb_mem_size, 0,
3706                                    ION_HEAP(ION_VMALLOC_HEAP_ID), 0);
3707         else
3708                 handle = ion_alloc(rk_fb->ion_client, (size_t) fb_mem_size, 0,
3709                                    ION_HEAP(ION_CMA_HEAP_ID), 0);
3710         if (IS_ERR(handle)) {
3711                 dev_err(fbi->device, "failed to ion_alloc:%ld\n",
3712                         PTR_ERR(handle));
3713                 return -ENOMEM;
3714         }
3715
3716         fb_par->ion_hdl = handle;
3717         win->area[0].dma_buf = ion_share_dma_buf(rk_fb->ion_client, handle);
3718         if (IS_ERR_OR_NULL(win->area[0].dma_buf)) {
3719                 printk("ion_share_dma_buf() failed\n");
3720                 goto err_share_dma_buf;
3721         }
3722         win->area[0].ion_hdl = handle;
3723         if (dev_drv->prop == PRMRY)
3724                 fbi->screen_base = ion_map_kernel(rk_fb->ion_client, handle);
3725 #ifdef CONFIG_ROCKCHIP_IOMMU
3726         if (dev_drv->iommu_enabled && dev_drv->mmu_dev)
3727                 ret = ion_map_iommu(dev_drv->dev, rk_fb->ion_client, handle,
3728                                         (unsigned long *)&phy_addr,
3729                                         (unsigned long *)&len);
3730         else
3731                 ret = ion_phys(rk_fb->ion_client, handle, &phy_addr, &len);
3732 #else
3733         ret = ion_phys(rk_fb->ion_client, handle, &phy_addr, &len);
3734 #endif
3735         if (ret < 0) {
3736                 dev_err(fbi->dev, "ion map to get phy addr failed\n");
3737                 goto err_share_dma_buf;
3738         }
3739         fbi->fix.smem_start = phy_addr;
3740         fbi->fix.smem_len = len;
3741         printk(KERN_INFO "alloc_buffer:ion_phy_addr=0x%lx\n", phy_addr);
3742         return 0;
3743
3744 err_share_dma_buf:
3745         ion_free(rk_fb->ion_client, handle);
3746         return -ENOMEM;
3747 }
3748 #endif
3749
3750 static int rk_fb_alloc_buffer(struct fb_info *fbi, int fb_id)
3751 {
3752         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3753         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
3754         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
3755         struct rk_lcdc_win *win = NULL;
3756         int win_id;
3757         int ret = 0;
3758         unsigned long fb_mem_size;
3759 #if !defined(CONFIG_ION_ROCKCHIP)
3760         dma_addr_t fb_mem_phys;
3761         void *fb_mem_virt;
3762 #endif
3763
3764         win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
3765         if (win_id < 0)
3766                 return -ENODEV;
3767         else
3768                 win = dev_drv->win[win_id];
3769
3770         if (!strcmp(fbi->fix.id, "fb0")) {
3771                 fb_mem_size = get_fb_size();
3772 #if defined(CONFIG_ION_ROCKCHIP)
3773                 if (rk_fb_alloc_buffer_by_ion(fbi, win, fb_mem_size) < 0)
3774                         return -ENOMEM;
3775 #else
3776                 fb_mem_virt = dma_alloc_writecombine(fbi->dev, fb_mem_size,
3777                                                      &fb_mem_phys, GFP_KERNEL);
3778                 if (!fb_mem_virt) {
3779                         pr_err("%s: Failed to allocate framebuffer\n",
3780                                __func__);
3781                         return -ENOMEM;
3782                 }
3783                 fbi->fix.smem_len = fb_mem_size;
3784                 fbi->fix.smem_start = fb_mem_phys;
3785                 fbi->screen_base = fb_mem_virt;
3786 #endif
3787                 memset(fbi->screen_base, 0, fbi->fix.smem_len);
3788                 printk(KERN_INFO "fb%d:phy:%lx>>vir:%p>>len:0x%x\n", fb_id,
3789                        fbi->fix.smem_start, fbi->screen_base,
3790                        fbi->fix.smem_len);
3791         } else {
3792                 if (dev_drv->rotate_mode > X_Y_MIRROR) {
3793                         fb_mem_size = get_rotate_fb_size();
3794 #if defined(CONFIG_ION_ROCKCHIP)
3795                         if (rk_fb_alloc_buffer_by_ion(fbi, win, fb_mem_size) < 0)
3796                                 return -ENOMEM;
3797 #else
3798                         fb_mem_virt =
3799                                 dma_alloc_writecombine(fbi->dev,
3800                                                        fb_mem_size,
3801                                                        &fb_mem_phys,
3802                                                        GFP_KERNEL);
3803                         if (!fb_mem_virt) {
3804                                 pr_err("%s: Failed to allocate framebuffer\n",
3805                                         __func__);
3806                                 return -ENOMEM;
3807                         }
3808                         fbi->fix.smem_len = fb_mem_size;
3809                         fbi->fix.smem_start = fb_mem_phys;
3810                         fbi->screen_base = fb_mem_virt;
3811 #endif
3812                 } else {
3813                         fbi->fix.smem_start = rk_fb->fb[0]->fix.smem_start;
3814                         fbi->fix.smem_len = rk_fb->fb[0]->fix.smem_len;
3815                         fbi->screen_base = rk_fb->fb[0]->screen_base;
3816                 }
3817
3818                 printk(KERN_INFO "fb%d:phy:%lx>>vir:%p>>len:0x%x\n", fb_id,
3819                        fbi->fix.smem_start, fbi->screen_base,
3820                        fbi->fix.smem_len);
3821         }
3822
3823         fbi->screen_size = fbi->fix.smem_len;
3824         fb_par->fb_phy_base = fbi->fix.smem_start;
3825         fb_par->fb_virt_base = fbi->screen_base;
3826         fb_par->fb_size = fbi->fix.smem_len;
3827
3828         return ret;
3829 }
3830
3831 #if 0
3832 static int rk_release_fb_buffer(struct fb_info *fbi)
3833 {
3834         /* buffer for fb1 and fb3 are alloc by android */
3835         if (!strcmp(fbi->fix.id, "fb1") || !strcmp(fbi->fix.id, "fb3"))
3836                 return 0;
3837         iounmap(fbi->screen_base);
3838         release_mem_region(fbi->fix.smem_start, fbi->fix.smem_len);
3839         return 0;
3840 }
3841 #endif
3842
3843 static int init_lcdc_win(struct rk_lcdc_driver *dev_drv,
3844                          struct rk_lcdc_win *def_win)
3845 {
3846         int i;
3847         int lcdc_win_num = dev_drv->lcdc_win_num;
3848
3849         for (i = 0; i < lcdc_win_num; i++) {
3850                 struct rk_lcdc_win *win = NULL;
3851                 win = kzalloc(sizeof(struct rk_lcdc_win), GFP_KERNEL);
3852                 if (!win) {
3853                         dev_err(dev_drv->dev, "kzmalloc for win fail!");
3854                         return -ENOMEM;
3855                 }
3856
3857                 strcpy(win->name, def_win[i].name);
3858                 win->id = def_win[i].id;
3859                 win->support_3d = def_win[i].support_3d;
3860                 dev_drv->win[i] = win;
3861         }
3862
3863         return 0;
3864 }
3865
3866 static int init_lcdc_device_driver(struct rk_fb *rk_fb,
3867                                    struct rk_lcdc_win *def_win, int index)
3868 {
3869         struct rk_lcdc_driver *dev_drv = rk_fb->lcdc_dev_drv[index];
3870         struct rk_screen *screen = devm_kzalloc(dev_drv->dev,
3871                                                 sizeof(struct rk_screen),
3872                                                 GFP_KERNEL);
3873
3874         if (!screen) {
3875                 dev_err(dev_drv->dev, "malloc screen for lcdc%d fail!",
3876                         dev_drv->id);
3877                 return -ENOMEM;
3878         }
3879
3880         screen->screen_id = 0;
3881         screen->lcdc_id = dev_drv->id;
3882         screen->overscan.left = 100;
3883         screen->overscan.top = 100;
3884         screen->overscan.right = 100;
3885         screen->overscan.bottom = 100;
3886
3887         screen->x_mirror = dev_drv->rotate_mode & X_MIRROR;
3888         screen->y_mirror = dev_drv->rotate_mode & Y_MIRROR;
3889
3890         dev_drv->screen0 = screen;
3891         dev_drv->cur_screen = screen;
3892         /* devie use one lcdc + rk61x scaler for dual display */
3893         if (rk_fb->disp_mode == ONE_DUAL) {
3894                 struct rk_screen *screen1 =
3895                                 devm_kzalloc(dev_drv->dev,
3896                                              sizeof(struct rk_screen),
3897                                              GFP_KERNEL);
3898                 if (!screen1) {
3899                         dev_err(dev_drv->dev, "malloc screen1 for lcdc%d fail!",
3900                                 dev_drv->id);
3901                         return -ENOMEM;
3902                 }
3903                 screen1->screen_id = 1;
3904                 screen1->lcdc_id = 1;
3905                 dev_drv->screen1 = screen1;
3906         }
3907         sprintf(dev_drv->name, "lcdc%d", dev_drv->id);
3908         init_lcdc_win(dev_drv, def_win);
3909         init_completion(&dev_drv->frame_done);
3910         spin_lock_init(&dev_drv->cpl_lock);
3911         mutex_init(&dev_drv->fb_win_id_mutex);
3912         dev_drv->ops->fb_win_remap(dev_drv, dev_drv->fb_win_map);
3913         dev_drv->first_frame = 1;
3914         dev_drv->overscan.left = 100;
3915         dev_drv->overscan.top = 100;
3916         dev_drv->overscan.right = 100;
3917         dev_drv->overscan.bottom = 100;
3918         rk_disp_pwr_ctr_parse_dt(dev_drv);
3919         if (dev_drv->prop == PRMRY) {
3920                 if (dev_drv->ops->set_dsp_cabc)
3921                         dev_drv->ops->set_dsp_cabc(dev_drv, dev_drv->cabc_mode);
3922                 rk_fb_set_prmry_screen(screen);
3923                 rk_fb_get_prmry_screen(screen);
3924         }
3925         dev_drv->trsm_ops = rk_fb_trsm_ops_get(screen->type);
3926         if (dev_drv->prop != PRMRY)
3927                 rk_fb_get_prmry_screen(screen);
3928         dev_drv->output_color = screen->color_mode;
3929
3930         return 0;
3931 }
3932
3933 #ifdef CONFIG_LOGO_LINUX_BMP
3934 static struct linux_logo *bmp_logo;
3935 static int fb_prewine_bmp_logo(struct fb_info *info, int rotate)
3936 {
3937         bmp_logo = fb_find_logo(24);
3938         if (bmp_logo == NULL) {
3939                 printk(KERN_INFO "%s error\n", __func__);
3940                 return 0;
3941         }
3942         return 1;
3943 }
3944
3945 static void fb_show_bmp_logo(struct fb_info *info, int rotate)
3946 {
3947         unsigned char *src = bmp_logo->data;
3948         unsigned char *dst = info->screen_base;
3949         int i;
3950         unsigned int Needwidth = (*(src - 24) << 8) | (*(src - 23));
3951         unsigned int Needheight = (*(src - 22) << 8) | (*(src - 21));
3952
3953         for (i = 0; i < Needheight; i++)
3954                 memcpy(dst + info->var.xres * i * 4,
3955                        src + bmp_logo->width * i * 4, Needwidth * 4);
3956 }
3957 #endif
3958
3959 /*
3960  * check if the primary lcdc has registerd,
3961  * the primary lcdc mas register first
3962  */
3963 bool is_prmry_rk_lcdc_registered(void)
3964 {
3965         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3966
3967         if (rk_fb->lcdc_dev_drv[0])
3968                 return true;
3969         else
3970                 return false;
3971 }
3972
3973 int rk_fb_register(struct rk_lcdc_driver *dev_drv,
3974                    struct rk_lcdc_win *win, int id)
3975 {
3976         struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
3977         struct fb_info *fbi;
3978         struct rk_fb_par *fb_par = NULL;
3979         int i = 0, ret = 0, index = 0;
3980
3981         if (rk_fb->num_lcdc == RK30_MAX_LCDC_SUPPORT)
3982                 return -ENXIO;
3983
3984         for (i = 0; i < RK30_MAX_LCDC_SUPPORT; i++) {
3985                 if (!rk_fb->lcdc_dev_drv[i]) {
3986                         rk_fb->lcdc_dev_drv[i] = dev_drv;
3987                         rk_fb->lcdc_dev_drv[i]->id = id;
3988                         rk_fb->num_lcdc++;
3989                         break;
3990                 }
3991         }
3992
3993         index = i;
3994         init_lcdc_device_driver(rk_fb, win, index);
3995         dev_drv->fb_index_base = rk_fb->num_fb;
3996         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3997                 fbi = framebuffer_alloc(0, &fb_pdev->dev);
3998                 if (!fbi) {
3999                         dev_err(&fb_pdev->dev, "fb framebuffer_alloc fail!");
4000                         ret = -ENOMEM;
4001                 }
4002                 fb_par = devm_kzalloc(&fb_pdev->dev, sizeof(struct rk_fb_par),
4003                                       GFP_KERNEL);
4004                 if (!fb_par) {
4005                         dev_err(&fb_pdev->dev, "malloc fb_par for fb%d fail!",
4006                                 rk_fb->num_fb);
4007                         return -ENOMEM;
4008                 }
4009                 fb_par->id = rk_fb->num_fb;
4010                 fb_par->lcdc_drv = dev_drv;
4011                 fbi->par = (void *)fb_par;
4012                 fbi->var = def_var;
4013                 fbi->fix = def_fix;
4014                 sprintf(fbi->fix.id, "fb%d", rk_fb->num_fb);
4015                 fb_videomode_to_var(&fbi->var, &dev_drv->cur_screen->mode);
4016                 fbi->var.grayscale |=
4017                     (fbi->var.xres << 8) + (fbi->var.yres << 20);
4018 #if defined(CONFIG_LOGO_LINUX_BMP)
4019                 fbi->var.bits_per_pixel = 32;
4020 #else
4021                 fbi->var.bits_per_pixel = 16;
4022 #endif
4023                 fbi->fix.line_length =
4024                     (fbi->var.xres_virtual) * (fbi->var.bits_per_pixel >> 3);
4025                 fbi->var.width = dev_drv->cur_screen->width;
4026                 fbi->var.height = dev_drv->cur_screen->height;
4027                 fbi->var.pixclock = dev_drv->pixclock;
4028                 if (dev_drv->iommu_enabled)
4029                         fb_ops.fb_mmap = rk_fb_mmap;
4030                 fbi->fbops = &fb_ops;
4031                 fbi->flags = FBINFO_FLAG_DEFAULT;
4032                 fbi->pseudo_palette = dev_drv->win[i]->pseudo_pal;
4033                 ret = register_framebuffer(fbi);
4034                 if (ret < 0) {
4035                         dev_err(&fb_pdev->dev,
4036                                 "%s fb%d register_framebuffer fail!\n",
4037                                 __func__, rk_fb->num_fb);
4038                         return ret;
4039                 }
4040                 rkfb_create_sysfs(fbi);
4041                 rk_fb->fb[rk_fb->num_fb] = fbi;
4042                 dev_info(fbi->dev, "rockchip framebuffer registerd:%s\n",
4043                          fbi->fix.id);
4044                 rk_fb->num_fb++;
4045
4046                 if (i == 0) {
4047                         init_waitqueue_head(&dev_drv->vsync_info.wait);
4048                         init_waitqueue_head(&dev_drv->update_regs_wait);
4049                         ret = device_create_file(fbi->dev, &dev_attr_vsync);
4050                         if (ret)
4051                                 dev_err(fbi->dev,
4052                                         "failed to create vsync file\n");
4053                         dev_drv->vsync_info.thread =
4054                             kthread_run(rk_fb_wait_for_vsync_thread, dev_drv,
4055                                         "fb-vsync");
4056                         if (dev_drv->vsync_info.thread == ERR_PTR(-ENOMEM)) {
4057                                 dev_err(fbi->dev,
4058                                         "failed to run vsync thread\n");
4059                                 dev_drv->vsync_info.thread = NULL;
4060                         }
4061                         dev_drv->vsync_info.active = 1;
4062
4063                         mutex_init(&dev_drv->output_lock);
4064
4065                         INIT_LIST_HEAD(&dev_drv->update_regs_list);
4066                         mutex_init(&dev_drv->update_regs_list_lock);
4067                         init_kthread_worker(&dev_drv->update_regs_worker);
4068
4069                         dev_drv->update_regs_thread =
4070                             kthread_run(kthread_worker_fn,
4071                                         &dev_drv->update_regs_worker, "rk-fb");
4072                         if (IS_ERR(dev_drv->update_regs_thread)) {
4073                                 int err = PTR_ERR(dev_drv->update_regs_thread);
4074                                 dev_drv->update_regs_thread = NULL;
4075
4076                                 printk("failed to run update_regs thread\n");
4077                                 return err;
4078                         }
4079                         init_kthread_work(&dev_drv->update_regs_work,
4080                                           rk_fb_update_regs_handler);
4081
4082                         dev_drv->timeline =
4083                             sw_sync_timeline_create("fb-timeline");
4084                         dev_drv->timeline_max = 1;
4085                 }
4086         }
4087
4088         /* show logo for primary display device */
4089 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE)
4090         if (dev_drv->prop == PRMRY) {
4091                 struct fb_info *main_fbi = rk_fb->fb[0];
4092                 main_fbi->fbops->fb_open(main_fbi, 1);
4093
4094 #if defined(CONFIG_ROCKCHIP_IOMMU)
4095                 if (dev_drv->iommu_enabled) {
4096                         if (dev_drv->mmu_dev)
4097                                 rockchip_iovmm_set_fault_handler(dev_drv->dev,
4098                                                 rk_fb_sysmmu_fault_handler);
4099                 }
4100 #endif
4101
4102                 rk_fb_alloc_buffer(main_fbi, 0);        /* only alloc memory for main fb */
4103                 dev_drv->uboot_logo = support_uboot_display();
4104 #if !defined(CONFIG_LOGO)
4105                 if (support_uboot_display()) {
4106                         /*
4107                         if (dev_drv->iommu_enabled)
4108                                 rk_fb_copy_from_loader(main_fbi);
4109                         */
4110                         return 0;
4111                 }
4112 #else
4113                 main_fbi->fbops->fb_set_par(main_fbi);
4114 #if  defined(CONFIG_LOGO_LINUX_BMP)
4115                 if (fb_prewine_bmp_logo(main_fbi, FB_ROTATE_UR)) {
4116                         fb_set_cmap(&main_fbi->cmap, main_fbi);
4117                         fb_show_bmp_logo(main_fbi, FB_ROTATE_UR);
4118                 }
4119 #else
4120                 if (fb_prepare_logo(main_fbi, FB_ROTATE_UR)) {
4121                         fb_set_cmap(&main_fbi->cmap, main_fbi);
4122                         fb_show_logo(main_fbi, FB_ROTATE_UR);
4123                 }
4124 #endif
4125                 main_fbi->fbops->fb_pan_display(&main_fbi->var, main_fbi);
4126 #endif
4127         } else {
4128                 struct fb_info *extend_fbi = rk_fb->fb[rk_fb->num_fb >> 1];
4129                 int extend_fb_id = get_extend_fb_id(extend_fbi);
4130
4131                 rk_fb_alloc_buffer(extend_fbi, extend_fb_id);
4132         }
4133 #endif
4134         return 0;
4135 }
4136
4137 int rk_fb_unregister(struct rk_lcdc_driver *dev_drv)
4138 {
4139         struct rk_fb *fb_inf = platform_get_drvdata(fb_pdev);
4140         struct fb_info *fbi;
4141         int fb_index_base = dev_drv->fb_index_base;
4142         int fb_num = dev_drv->lcdc_win_num;
4143         int i = 0;
4144
4145         if (fb_inf->lcdc_dev_drv[i]->vsync_info.thread) {
4146                 fb_inf->lcdc_dev_drv[i]->vsync_info.irq_stop = 1;
4147                 kthread_stop(fb_inf->lcdc_dev_drv[i]->vsync_info.thread);
4148         }
4149
4150         for (i = 0; i < fb_num; i++)
4151                 kfree(dev_drv->win[i]);
4152
4153         for (i = fb_index_base; i < (fb_index_base + fb_num); i++) {
4154                 fbi = fb_inf->fb[i];
4155                 unregister_framebuffer(fbi);
4156                 /* rk_release_fb_buffer(fbi); */
4157                 framebuffer_release(fbi);
4158         }
4159         fb_inf->lcdc_dev_drv[dev_drv->id] = NULL;
4160         fb_inf->num_lcdc--;
4161
4162         return 0;
4163 }
4164
4165 static int rk_fb_probe(struct platform_device *pdev)
4166 {
4167         struct rk_fb *rk_fb = NULL;
4168         struct device_node *np = pdev->dev.of_node;
4169         u32 mode;
4170
4171         if (!np) {
4172                 dev_err(&pdev->dev, "Missing device tree node.\n");
4173                 return -EINVAL;
4174         }
4175
4176         rk_fb = devm_kzalloc(&pdev->dev, sizeof(struct rk_fb), GFP_KERNEL);
4177         if (!rk_fb) {
4178                 dev_err(&pdev->dev, "kmalloc for rk fb fail!");
4179                 return -ENOMEM;
4180         }
4181         platform_set_drvdata(pdev, rk_fb);
4182
4183         if (!of_property_read_u32(np, "rockchip,disp-mode", &mode)) {
4184                 rk_fb->disp_mode = mode;
4185
4186         } else {
4187                 dev_err(&pdev->dev, "no disp-mode node found!");
4188                 return -ENODEV;
4189         }
4190
4191         if (!of_property_read_u32(np, "rockchip,disp-policy", &mode)) {
4192                 rk_fb->disp_policy = mode;
4193                 pr_info("fb disp policy is %s\n", rk_fb->disp_policy ? "box":"sdk");
4194         }
4195
4196         if (!of_property_read_u32(np, "rockchip,uboot-logo-on", &uboot_logo_on))
4197                 printk(KERN_DEBUG "uboot-logo-on:%d\n", uboot_logo_on);
4198
4199         dev_set_name(&pdev->dev, "rockchip-fb");
4200 #if defined(CONFIG_ION_ROCKCHIP)
4201         rk_fb->ion_client = rockchip_ion_client_create("rk_fb");
4202         if (IS_ERR(rk_fb->ion_client)) {
4203                 dev_err(&pdev->dev, "failed to create ion client for rk fb");
4204                 return PTR_ERR(rk_fb->ion_client);
4205         } else {
4206                 dev_info(&pdev->dev, "rk fb ion client create success!\n");
4207         }
4208 #endif
4209
4210         fb_pdev = pdev;
4211         dev_info(&pdev->dev, "rockchip framebuffer driver probe\n");
4212         return 0;
4213 }
4214
4215 static int rk_fb_remove(struct platform_device *pdev)
4216 {
4217         struct rk_fb *rk_fb = platform_get_drvdata(pdev);
4218
4219         kfree(rk_fb);
4220         platform_set_drvdata(pdev, NULL);
4221         return 0;
4222 }
4223
4224 static void rk_fb_shutdown(struct platform_device *pdev)
4225 {
4226         struct rk_fb *rk_fb = platform_get_drvdata(pdev);
4227         int i;
4228
4229         for (i = 0; i < rk_fb->num_lcdc; i++) {
4230                 if (!rk_fb->lcdc_dev_drv[i])
4231                         continue;
4232         }
4233 }
4234
4235 static const struct of_device_id rkfb_dt_ids[] = {
4236         {.compatible = "rockchip,rk-fb",},
4237         {}
4238 };
4239
4240 static struct platform_driver rk_fb_driver = {
4241         .probe = rk_fb_probe,
4242         .remove = rk_fb_remove,
4243         .driver = {
4244                    .name = "rk-fb",
4245                    .owner = THIS_MODULE,
4246                    .of_match_table = of_match_ptr(rkfb_dt_ids),
4247                    },
4248         .shutdown = rk_fb_shutdown,
4249 };
4250
4251 static int __init rk_fb_init(void)
4252 {
4253         return platform_driver_register(&rk_fb_driver);
4254 }
4255
4256 static void __exit rk_fb_exit(void)
4257 {
4258         platform_driver_unregister(&rk_fb_driver);
4259 }
4260
4261 fs_initcall(rk_fb_init);
4262 module_exit(rk_fb_exit);