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