drivers/video/rockchip/rk_fb.c

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