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