drivers/video/rockchip/lcdc/rk322x_lcdc.c

   1 /*
   2  * drivers/video/rockchip/lcdc/rk322x_lcdc.c
   3  *
   4  * Copyright (C) 2015 ROCKCHIP, Inc.
   5  * Author: Mark Yao <mark.yao@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
  17 #include <linux/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/errno.h>
  20 #include <linux/string.h>
  21 #include <linux/mm.h>
  22 #include <linux/slab.h>
  23 #include <linux/device.h>
  24 #include <linux/delay.h>
  25 #include <linux/init.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/of_device.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/clk.h>
  30 #include <linux/rockchip-iovmm.h>
  31 #include <asm/div64.h>
  32 #include <linux/uaccess.h>
  33 #include <linux/rockchip/iomap.h>
  34 #include <linux/rockchip/grf.h>
  35 #include <linux/rockchip/common.h>
  36 #include <dt-bindings/clock/rk_system_status.h>
  37
  38 #include "rk322x_lcdc.h"
  39
  40 /*#define CONFIG_RK_FPGA 1*/
  41 #define VOP_CHIP(dev)   (dev->data->chip_type)
  42
  43 static int dbg_thresd;
  44 module_param(dbg_thresd, int, S_IRUGO | S_IWUSR);
  45
  46 #define DBG(level, x...) do {                   \
  47         if (unlikely(dbg_thresd >= level))      \
  48                 pr_info(x);\
  49         } while (0)
  50
  51 static struct rk_lcdc_win rk322x_vop_win[] = {
  52         { .name = "win0",
  53           .id = VOP_WIN0,
  54           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
  55                                 SUPPORT_SCALE | SUPPORT_YUV |
  56                                 SUPPORT_YUV10BIT,
  57           .property.max_input_x = 4096,
  58           .property.max_input_y = 2304},
  59         { .name = "win1",
  60           .id = VOP_WIN1,
  61           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
  62                                 SUPPORT_SCALE | SUPPORT_YUV |
  63                                 SUPPORT_YUV10BIT,
  64           .property.max_input_x = 4096,
  65           .property.max_input_y = 2304},
  66         {
  67           .name = "hwc",
  68           .id = VOP_HWC,
  69           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
  70                                 SUPPORT_HWC_LAYER,
  71           .property.max_input_x = 128,
  72           .property.max_input_y = 128
  73         }
  74 };
  75
  76 static struct rk_lcdc_win rk3399_vop_win[] = {
  77         { .name = "win0",
  78           .id = VOP_WIN0,
  79           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
  80                                 SUPPORT_SCALE | SUPPORT_YUV |
  81                                 SUPPORT_YUV10BIT,
  82           .property.max_input_x = 4096,
  83           .property.max_input_y = 2304},
  84         { .name = "win1",
  85           .id = VOP_WIN1,
  86           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
  87                                 SUPPORT_SCALE | SUPPORT_YUV |
  88                                 SUPPORT_YUV10BIT,
  89           .property.max_input_x = 4096,
  90           .property.max_input_y = 2304},
  91         { .name = "win2",
  92           .id = VOP_WIN2,
  93           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
  94                                 SUPPORT_MULTI_AREA,
  95           .property.max_input_x = 4096,
  96           .property.max_input_y = 2304},
  97         { .name = "win3",
  98           .id = VOP_WIN3,
  99           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
 100                                 SUPPORT_MULTI_AREA,
 101           .property.max_input_x = 4096,
 102           .property.max_input_y = 2304},
 103         {
 104           .name = "hwc",
 105           .id = VOP_HWC,
 106           .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
 107                                 SUPPORT_HWC_LAYER,
 108           .property.max_input_x = 128,
 109           .property.max_input_y = 128
 110         }
 111 };
 112
 113 static const struct vop_data rk322x_data = {
 114         .chip_type = VOP_RK322X,
 115         .win = rk322x_vop_win,
 116         .n_wins = ARRAY_SIZE(rk322x_vop_win),
 117 };
 118
 119 static const struct vop_data rk3399_data = {
 120         .chip_type = VOP_RK3399,
 121         .win = rk3399_vop_win,
 122         .n_wins = ARRAY_SIZE(rk3399_vop_win),
 123 };
 124
 125 #if defined(CONFIG_OF)
 126 static const struct of_device_id vop_dt_ids[] = {
 127         {.compatible = "rockchip,rk322x-lcdc",
 128          .data = &rk322x_data, },
 129         {.compatible = "rockchip,rk3399-lcdc",
 130          .data = &rk3399_data, },
 131         {}
 132 };
 133 #endif
 134
 135 static const u32 csc_y2r_bt601_limit[12] = {
 136         0x04a8,      0,  0x0662, 0xfffc8654,
 137         0x04a8, 0xfe6f,  0xfcbf, 0x00022056,
 138         0x04a8, 0x0812,       0, 0xfffbaeac,
 139 };
 140
 141 static const u32 csc_y2r_bt709_full[12] = {
 142         0x04a8,      0,  0x072c, 0xfffc219e,
 143         0x04a8, 0xff26,  0xfdde, 0x0001357b,
 144         0x04a8, 0x0873,       0, 0xfffb7dee,
 145 };
 146
 147 static const u32 csc_y2r_bt601_full[12] = {
 148         0x0400,      0,  0x059c, 0xfffd342d,
 149         0x0400, 0xfea0,  0xfd25, 0x00021fcc,
 150         0x0400, 0x0717,       0, 0xfffc76bc,
 151 };
 152
 153 static const u32 csc_y2r_bt601_limit_10[12] = {
 154         0x04a8,      0,  0x0662, 0xfff2134e,
 155         0x04a8, 0xfe6f,  0xfcbf, 0x00087b58,
 156         0x04a8, 0x0812,       0, 0xffeeb4b0,
 157 };
 158
 159 static const u32 csc_y2r_bt709_full_10[12] = {
 160         0x04a8,      0,  0x072c, 0xfff08077,
 161         0x04a8, 0xff26,  0xfdde, 0x0004cfed,
 162         0x04a8, 0x0873,       0, 0xffedf1b8,
 163 };
 164
 165 static const u32 csc_y2r_bt601_full_10[12] = {
 166         0x0400,      0,  0x059c, 0xfff4cab4,
 167         0x0400, 0xfea0,  0xfd25, 0x00087932,
 168         0x0400, 0x0717,       0, 0xfff1d4f2,
 169 };
 170
 171 static const u32 csc_y2r_bt2020[12] = {
 172         0x04a8,      0, 0x06b6, 0xfff16bfc,
 173         0x04a8, 0xff40, 0xfd66, 0x58ae9,
 174         0x04a8, 0x0890,      0, 0xffedb828,
 175 };
 176
 177 static const u32 csc_r2y_bt601_limit[12] = {
 178         0x0107, 0x0204, 0x0064, 0x04200,
 179         0xff68, 0xfed6, 0x01c2, 0x20200,
 180         0x01c2, 0xfe87, 0xffb7, 0x20200,
 181 };
 182
 183 static const u32 csc_r2y_bt709_full[12] = {
 184         0x00bb, 0x0275, 0x003f, 0x04200,
 185         0xff99, 0xfea5, 0x01c2, 0x20200,
 186         0x01c2, 0xfe68, 0xffd7, 0x20200,
 187 };
 188
 189 static const u32 csc_r2y_bt601_full[12] = {
 190         0x0132, 0x0259, 0x0075, 0x200,
 191         0xff53, 0xfead, 0x0200, 0x20200,
 192         0x0200, 0xfe53, 0xffad, 0x20200,
 193 };
 194
 195 static const u32 csc_r2y_bt601_limit_10[12] = {
 196         0x0107, 0x0204, 0x0064, 0x10200,
 197         0xff68, 0xfed6, 0x01c2, 0x80200,
 198         0x01c2, 0xfe87, 0xffb7, 0x80200,
 199 };
 200
 201 static const u32 csc_r2y_bt709_full_10[12] = {
 202         0x00bb, 0x0275, 0x003f, 0x10200,
 203         0xff99, 0xfea5, 0x01c2, 0x80200,
 204         0x01c2, 0xfe68, 0xffd7, 0x80200,
 205 };
 206
 207 static const u32 csc_r2y_bt601_full_10[12] = {
 208         0x0132, 0x0259, 0x0075, 0x200,
 209         0xff53, 0xfead, 0x0200, 0x80200,
 210         0x0200, 0xfe53, 0xffad, 0x80200,
 211 };
 212
 213 static const u32 csc_r2y_bt2020[12] = {
 214         0x00e6, 0x0253, 0x0034, 0x10200,
 215         0xff83, 0xfebd, 0x01c1, 0x80200,
 216         0x01c1, 0xfe64, 0xffdc, 0x80200,
 217 };
 218
 219 static const u32 csc_r2r_bt2020to709[12] = {
 220         0x06a4, 0xfda6, 0xffb5, 0x200,
 221         0xff80, 0x0488, 0xfff8, 0x200,
 222         0xffed, 0xff99, 0x047a, 0x200,
 223 };
 224
 225 static const u32 csc_r2r_bt709to2020[12] = {
 226         0x282, 0x151, 0x02c, 0x200,
 227         0x047, 0x3ae, 0x00c, 0x200,
 228         0x011, 0x05a, 0x395, 0x200,
 229 };
 230
 231 static int vop_get_id(struct vop_device *vop_dev, u32 phy_base)
 232 {
 233         if (VOP_CHIP(vop_dev) == VOP_RK3399) {
 234                 if (phy_base == 0xff900000) /* vop big */
 235                         return 0;
 236                 else if (phy_base == 0xff8f0000) /* vop lit */
 237                         return 1;
 238                 else
 239                         return -EINVAL;
 240         } else {
 241                 return 0;
 242         }
 243 }
 244
 245 static void vop_load_csc_table(struct vop_device *vop_dev, u32 offset,
 246                                const u32 *table)
 247 {
 248         u32 csc_val;
 249
 250         csc_val = table[1] << 16 | table[0];
 251         vop_writel(vop_dev, offset, csc_val);
 252         csc_val = table[4] << 16 | table[2];
 253         vop_writel(vop_dev, offset + 4, csc_val);
 254         csc_val = table[6] << 16 | table[5];
 255         vop_writel(vop_dev, offset + 8, csc_val);
 256         csc_val = table[9] << 16 | table[8];
 257         vop_writel(vop_dev, offset + 0xc, csc_val);
 258         csc_val = table[10];
 259         vop_writel(vop_dev, offset + 0x10, csc_val);
 260         csc_val = table[3];
 261         vop_writel(vop_dev, offset + 0x14, csc_val);
 262         csc_val = table[7];
 263         vop_writel(vop_dev, offset + 0x18, csc_val);
 264         csc_val = table[11];
 265         vop_writel(vop_dev, offset + 0x1c, csc_val);
 266 }
 267
 268 #define LOAD_CSC(dev, mode, table, win_id) \
 269                 vop_load_csc_table(dev, \
 270                                    WIN0_YUV2YUV_##mode + 0x60 * win_id, \
 271                                    table)
 272
 273 static int vop_set_bcsh(struct rk_lcdc_driver *dev_drv, bool enable);
 274
 275 static int vop_set_lut(struct rk_lcdc_driver *dev_drv, int *dsp_lut)
 276 {
 277         struct vop_device *vop_dev =
 278                         container_of(dev_drv, struct vop_device, driver);
 279         int i, j;
 280
 281         if (!vop_dev->dsp_lut_addr_base) {
 282                 dev_warn(vop_dev->dev, "not support dsp lut config\n");
 283                 return 0;
 284         }
 285
 286         if (!dsp_lut) {
 287                 dev_err(vop_dev->dev, "dsp lut table is null\n");
 288                 return -EINVAL;
 289         }
 290
 291         spin_lock(&vop_dev->reg_lock);
 292         for (i = 0; i < 256; i++) {
 293                 u32 v, r, g, b;
 294                 int __iomem *c;
 295
 296                 v = dsp_lut[i];
 297                 c = vop_dev->dsp_lut_addr_base + (i << 2);
 298                 b = (v & 0xff) << 2;
 299                 g = (v & 0xff00) << 4;
 300                 r = (v & 0xff0000) << 6;
 301                 v = r + g + b;
 302                 for (j = 0; j < 4; j++) {
 303                         writel_relaxed(v, c);
 304                         v += (1 + (1 << 10) + (1 << 20));
 305                         c++;
 306                 }
 307         }
 308         vop_msk_reg(vop_dev, DSP_CTRL1, V_DSP_LUT_EN(1));
 309         /*
 310          * update_gamma value auto clean to 0 by HW, should not
 311          * bakeup it.
 312          */
 313         vop_msk_reg_nobak(vop_dev, DSP_CTRL1, V_UPDATE_GAMMA_LUT(1));
 314
 315         vop_cfg_done(vop_dev);
 316         spin_unlock(&vop_dev->reg_lock);
 317
 318         return 0;
 319 }
 320
 321 static int vop_set_cabc(struct rk_lcdc_driver *dev_drv, int *cabc_lut)
 322 {
 323         struct vop_device *vop_dev =
 324                         container_of(dev_drv, struct vop_device, driver);
 325         int i;
 326
 327         if (!vop_dev->cabc_lut_addr_base) {
 328                 dev_warn(vop_dev->dev, "not support cabc config\n");
 329                 return 0;
 330         }
 331
 332         if (!cabc_lut) {
 333                 dev_err(vop_dev->dev, "cabc lut table is null\n");
 334                 return -EINVAL;
 335         }
 336         spin_lock(&vop_dev->reg_lock);
 337         vop_msk_reg(vop_dev, CABC_CTRL1, V_CABC_LUT_EN(0));
 338         vop_cfg_done(vop_dev);
 339         spin_unlock(&vop_dev->reg_lock);
 340
 341         mdelay(25);
 342
 343         spin_lock(&vop_dev->reg_lock);
 344         for (i = 0; i < 128; i++) {
 345                 u32 v;
 346
 347                 v = cabc_lut[i];
 348
 349                 writel_relaxed(v, vop_dev->cabc_lut_addr_base + i);
 350         }
 351         vop_msk_reg(vop_dev, CABC_CTRL1, V_CABC_LUT_EN(1));
 352         spin_unlock(&vop_dev->reg_lock);
 353
 354         return 0;
 355 }
 356
 357 static int vop_clk_enable(struct vop_device *vop_dev)
 358 {
 359         if (!vop_dev->clk_on) {
 360                 clk_prepare_enable(vop_dev->hclk);
 361                 clk_prepare_enable(vop_dev->dclk);
 362                 clk_prepare_enable(vop_dev->aclk);
 363                 if (vop_dev->hclk_noc)
 364                         clk_prepare_enable(vop_dev->hclk_noc);
 365                 if (vop_dev->aclk_noc)
 366                         clk_prepare_enable(vop_dev->aclk_noc);
 367 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
 368                 pm_runtime_get_sync(vop_dev->dev);
 369 #endif
 370                 spin_lock(&vop_dev->reg_lock);
 371                 vop_dev->clk_on = 1;
 372                 spin_unlock(&vop_dev->reg_lock);
 373         }
 374
 375         return 0;
 376 }
 377
 378 static int vop_clk_disable(struct vop_device *vop_dev)
 379 {
 380         if (vop_dev->clk_on) {
 381                 spin_lock(&vop_dev->reg_lock);
 382                 vop_dev->clk_on = 0;
 383                 spin_unlock(&vop_dev->reg_lock);
 384                 mdelay(25);
 385 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
 386                 pm_runtime_put(vop_dev->dev);
 387 #endif
 388                 clk_disable_unprepare(vop_dev->dclk);
 389                 clk_disable_unprepare(vop_dev->hclk);
 390                 clk_disable_unprepare(vop_dev->aclk);
 391                 if (vop_dev->hclk_noc)
 392                         clk_disable_unprepare(vop_dev->hclk_noc);
 393                 if (vop_dev->aclk_noc)
 394                         clk_disable_unprepare(vop_dev->aclk_noc);
 395         }
 396
 397         return 0;
 398 }
 399
 400 static int __maybe_unused vop_disable_irq(struct vop_device *vop_dev)
 401 {
 402         if (likely(vop_dev->clk_on)) {
 403                 spin_lock(&vop_dev->reg_lock);
 404                 vop_writel(vop_dev, INTR_EN0, 0xffff0000);
 405                 vop_writel(vop_dev, INTR_EN1, 0xffff0000);
 406                 vop_writel(vop_dev, INTR_CLEAR0, 0xffffffff);
 407                 vop_writel(vop_dev, INTR_CLEAR1, 0xffffffff);
 408                 vop_cfg_done(vop_dev);
 409                 spin_unlock(&vop_dev->reg_lock);
 410         };
 411
 412         return 0;
 413 }
 414
 415 static int vop_reg_dump(struct rk_lcdc_driver *dev_drv)
 416 {
 417         struct vop_device *vop_dev =
 418             container_of(dev_drv, struct vop_device, driver);
 419         int *cbase = (int *)vop_dev->regs;
 420         int *regsbak = (int *)vop_dev->regsbak;
 421         int i, j, val;
 422         char dbg_message[30];
 423         char buf[10];
 424
 425         pr_info("lcd back up reg:\n");
 426         memset(dbg_message, 0, sizeof(dbg_message));
 427         memset(buf, 0, sizeof(buf));
 428         for (i = 0; i <= (0x200 >> 4); i++) {
 429                 val = sprintf(dbg_message, "0x%04x: ", i * 16);
 430                 for (j = 0; j < 4; j++) {
 431                         val = sprintf(buf, "%08x  ", *(regsbak + i * 4 + j));
 432                         strcat(dbg_message, buf);
 433                 }
 434                 pr_info("%s\n", dbg_message);
 435                 memset(dbg_message, 0, sizeof(dbg_message));
 436                 memset(buf, 0, sizeof(buf));
 437         }
 438
 439         pr_info("lcdc reg:\n");
 440         for (i = 0; i <= (0x200 >> 4); i++) {
 441                 val = sprintf(dbg_message, "0x%04x: ", i * 16);
 442                 for (j = 0; j < 4; j++) {
 443                         sprintf(buf, "%08x  ",
 444                                 readl_relaxed(cbase + i * 4 + j));
 445                         strcat(dbg_message, buf);
 446                 }
 447                 pr_info("%s\n", dbg_message);
 448                 memset(dbg_message, 0, sizeof(dbg_message));
 449                 memset(buf, 0, sizeof(buf));
 450         }
 451
 452         return 0;
 453 }
 454
 455 #define WIN_EN(id)              \
 456 static int win##id##_enable(struct vop_device *vop_dev, int en) \
 457 { \
 458         spin_lock(&vop_dev->reg_lock);                                  \
 459         vop_msk_reg(vop_dev, WIN##id##_CTRL0, V_WIN##id##_EN((u64)en)); \
 460         vop_cfg_done(vop_dev);                                          \
 461         spin_unlock(&vop_dev->reg_lock);                                \
 462         return 0;                                                       \
 463 }
 464
 465 WIN_EN(0);
 466 WIN_EN(1);
 467 WIN_EN(2);
 468 WIN_EN(3);
 469
 470 /*enable/disable win directly*/
 471 static int vop_win_direct_en(struct rk_lcdc_driver *drv,
 472                              int win_id, int en)
 473 {
 474         struct vop_device *vop_dev =
 475             container_of(drv, struct vop_device, driver);
 476
 477         drv->win[win_id]->state = en;
 478         if (win_id == 0)
 479                 win0_enable(vop_dev, en);
 480         else if (win_id == 1)
 481                 win1_enable(vop_dev, en);
 482         else if (win_id == 2)
 483                 win2_enable(vop_dev, en);
 484         else if (win_id == 3)
 485                 win3_enable(vop_dev, en);
 486         else
 487                 dev_err(vop_dev->dev, "invalid win number:%d\n", win_id);
 488         return 0;
 489 }
 490
 491 #define SET_WIN_ADDR(id) \
 492 static int set_win##id##_addr(struct vop_device *vop_dev, u32 addr) \
 493 {                                                       \
 494         spin_lock(&vop_dev->reg_lock);                  \
 495         vop_writel(vop_dev, WIN##id##_YRGB_MST, addr);  \
 496         vop_msk_reg(vop_dev, WIN##id##_CTRL0, V_WIN##id##_EN(1));       \
 497         vop_cfg_done(vop_dev);                  \
 498         spin_unlock(&vop_dev->reg_lock);                \
 499         return 0;                                       \
 500 }
 501
 502 SET_WIN_ADDR(0);
 503 SET_WIN_ADDR(1);
 504 int vop_direct_set_win_addr(struct rk_lcdc_driver *dev_drv,
 505                             int win_id, u32 addr)
 506 {
 507         struct vop_device *vop_dev =
 508             container_of(dev_drv, struct vop_device, driver);
 509         if (win_id == 0)
 510                 set_win0_addr(vop_dev, addr);
 511         else
 512                 set_win1_addr(vop_dev, addr);
 513
 514         return 0;
 515 }
 516
 517 static void lcdc_read_reg_defalut_cfg(struct vop_device *vop_dev)
 518 {
 519         int reg = 0;
 520         u32 val = 0;
 521         struct rk_screen *screen = vop_dev->driver.cur_screen;
 522         u32 h_pw_bp = screen->mode.hsync_len + screen->mode.left_margin;
 523         u32 V_pw_bp = screen->mode.vsync_len + screen->mode.upper_margin;
 524         u32 st_x, st_y;
 525         struct rk_lcdc_win *win0 = vop_dev->driver.win[0];
 526
 527         spin_lock(&vop_dev->reg_lock);
 528         for (reg = 0; reg < vop_dev->len; reg += 4) {
 529                 val = vop_readl_backup(vop_dev, reg);
 530                 switch (reg) {
 531                 case WIN0_ACT_INFO:
 532                         win0->area[0].xact = (val & MASK(WIN0_ACT_WIDTH)) + 1;
 533                         win0->area[0].yact =
 534                                 ((val & MASK(WIN0_ACT_HEIGHT)) >> 16) + 1;
 535                         break;
 536                 case WIN0_DSP_INFO:
 537                         win0->area[0].xsize = (val & MASK(WIN0_DSP_WIDTH)) + 1;
 538                         win0->area[0].ysize =
 539                             ((val & MASK(WIN0_DSP_HEIGHT)) >> 16) + 1;
 540                         break;
 541                 case WIN0_DSP_ST:
 542                         st_x = val & MASK(WIN0_DSP_XST);
 543                         st_y = (val & MASK(WIN0_DSP_YST)) >> 16;
 544                         win0->area[0].xpos = st_x - h_pw_bp;
 545                         win0->area[0].ypos = st_y - V_pw_bp;
 546                         break;
 547                 case WIN0_CTRL0:
 548                         win0->state = val & MASK(WIN0_EN);
 549                         win0->area[0].fmt_cfg =
 550                                         (val & MASK(WIN0_DATA_FMT)) >> 1;
 551                         win0->fmt_10 = (val & MASK(WIN0_FMT_10)) >> 4;
 552                         win0->area[0].format = win0->area[0].fmt_cfg;
 553                         break;
 554                 case WIN0_VIR:
 555                         win0->area[0].y_vir_stride =
 556                                         val & MASK(WIN0_VIR_STRIDE);
 557                         win0->area[0].uv_vir_stride =
 558                             (val & MASK(WIN0_VIR_STRIDE_UV)) >> 16;
 559                         if (win0->area[0].format == ARGB888)
 560                                 win0->area[0].xvir = win0->area[0].y_vir_stride;
 561                         else if (win0->area[0].format == RGB888)
 562                                 win0->area[0].xvir =
 563                                     win0->area[0].y_vir_stride * 4 / 3;
 564                         else if (win0->area[0].format == RGB565)
 565                                 win0->area[0].xvir =
 566                                     2 * win0->area[0].y_vir_stride;
 567                         else
 568                                 win0->area[0].xvir =
 569                                     4 * win0->area[0].y_vir_stride;
 570                         break;
 571                 case WIN0_YRGB_MST:
 572                         win0->area[0].smem_start = val;
 573                         break;
 574                 case WIN0_CBR_MST:
 575                         win0->area[0].cbr_start = val;
 576                         break;
 577                 default:
 578                         break;
 579                 }
 580         }
 581         spin_unlock(&vop_dev->reg_lock);
 582 }
 583
 584 /********do basic init*********/
 585 static int vop_pre_init(struct rk_lcdc_driver *dev_drv)
 586 {
 587         struct vop_device *vop_dev =
 588             container_of(dev_drv, struct vop_device, driver);
 589         if (vop_dev->pre_init)
 590                 return 0;
 591         vop_dev->hclk = devm_clk_get(vop_dev->dev, "hclk_lcdc");
 592         vop_dev->aclk = devm_clk_get(vop_dev->dev, "aclk_lcdc");
 593         vop_dev->dclk = devm_clk_get(vop_dev->dev, "dclk_lcdc");
 594         if (IS_ERR(vop_dev->aclk) || IS_ERR(vop_dev->dclk) ||
 595             IS_ERR(vop_dev->hclk))
 596                 dev_err(vop_dev->dev, "failed to get clk source\n");
 597         vop_dev->hclk_noc = devm_clk_get(vop_dev->dev, "hclk_vop_noc");
 598         if (IS_ERR(vop_dev->hclk_noc)) {
 599                 vop_dev->hclk_noc = NULL;
 600                 dev_err(vop_dev->dev, "failed to get clk source\n");
 601         }
 602         vop_dev->aclk_noc = devm_clk_get(vop_dev->dev, "aclk_vop_noc");
 603         if (IS_ERR(vop_dev->aclk_noc)) {
 604                 vop_dev->aclk_noc = NULL;
 605                 dev_err(vop_dev->dev, "failed to get clk source\n");
 606         }
 607         if (!support_uboot_display())
 608                 rk_disp_pwr_enable(dev_drv);
 609         vop_clk_enable(vop_dev);
 610
 611         memcpy(vop_dev->regsbak, vop_dev->regs, vop_dev->len);
 612         /*backup reg config at uboot */
 613         lcdc_read_reg_defalut_cfg(vop_dev);
 614         #ifndef CONFIG_RK_FPGA
 615         /*
 616          * Todo, not verified
 617          *
 618         if (vop_dev->pwr18 == 1) {
 619                 v = 0x00200020;
 620                 vop_grf_writel(vop_dev->pmugrf_base,
 621                                 PMUGRF_SOC_CON0_VOP, v);
 622         } else {
 623                 v = 0x00200000;
 624                 vop_grf_writel(vop_dev->pmugrf_base,
 625                                 PMUGRF_SOC_CON0_VOP, v);
 626         }
 627         */
 628         #endif
 629         vop_writel(vop_dev, FRC_LOWER01_0, 0x12844821);
 630         vop_writel(vop_dev, FRC_LOWER01_1, 0x21488412);
 631         vop_writel(vop_dev, FRC_LOWER10_0, 0xa55a9696);
 632         vop_writel(vop_dev, FRC_LOWER10_1, 0x5aa56969);
 633         vop_writel(vop_dev, FRC_LOWER11_0, 0xdeb77deb);
 634         vop_writel(vop_dev, FRC_LOWER11_1, 0xed7bb7de);
 635
 636         vop_msk_reg(vop_dev, SYS_CTRL, V_AUTO_GATING_EN(1));
 637         vop_msk_reg(vop_dev, DSP_CTRL1, V_DITHER_UP_EN(1));
 638         vop_cfg_done(vop_dev);
 639         vop_dev->pre_init = true;
 640
 641         return 0;
 642 }
 643
 644 static void vop_deint(struct vop_device *vop_dev)
 645 {
 646         if (vop_dev->clk_on) {
 647                 u64 val;
 648
 649                 vop_disable_irq(vop_dev);
 650                 spin_lock(&vop_dev->reg_lock);
 651                 vop_msk_reg(vop_dev, WIN0_CTRL0, V_WIN0_EN(0));
 652                 vop_msk_reg(vop_dev, WIN1_CTRL0, V_WIN0_EN(0));
 653
 654                 val = V_WIN2_EN(0) | V_WIN2_MST0_EN(0) | V_WIN2_MST1_EN(0) |
 655                         V_WIN2_MST2_EN(0) | V_WIN2_MST3_EN(0);
 656                 vop_msk_reg(vop_dev, WIN2_CTRL0, val);
 657                 vop_msk_reg(vop_dev, WIN3_CTRL0, val);
 658                 vop_cfg_done(vop_dev);
 659                 spin_unlock(&vop_dev->reg_lock);
 660                 mdelay(50);
 661         }
 662 }
 663
 664 static void vop_win_csc_mode(struct vop_device *vop_dev,
 665                              struct rk_lcdc_win *win,
 666                              int csc_mode)
 667 {
 668         u64 val;
 669
 670         if (win->id == VOP_WIN0) {
 671                 val = V_WIN0_CSC_MODE(csc_mode);
 672                 vop_msk_reg(vop_dev, WIN0_CTRL0, val);
 673         } else if (win->id == VOP_WIN1) {
 674                 val = V_WIN1_CSC_MODE(csc_mode);
 675                 vop_msk_reg(vop_dev, WIN1_CTRL0, val);
 676         } else {
 677                 val = V_HWC_CSC_MODE(csc_mode);
 678                 vop_msk_reg(vop_dev, HWC_CTRL0, val);
 679         }
 680 }
 681
 682 static int rk3399_vop_win_csc_cfg(struct rk_lcdc_driver *dev_drv)
 683 {
 684         struct vop_device *vop_dev =
 685             container_of(dev_drv, struct vop_device, driver);
 686         int output_color = dev_drv->output_color;
 687         int i;
 688
 689         for (i = 0; i < dev_drv->lcdc_win_num && i <= 4; i++) {
 690                 struct rk_lcdc_win *win = dev_drv->win[i];
 691                 int shift = i * 8;
 692                 u64 val = V_WIN0_YUV2YUV_EN(0) | V_WIN0_YUV2YUV_R2Y_EN(0) |
 693                                 V_WIN0_YUV2YUV_Y2R_EN(0);
 694
 695                 if (!win->state)
 696                         continue;
 697                 if (output_color == COLOR_RGB &&
 698                     !(IS_YUV(win->area[0].fmt_cfg) || win->area[0].yuyv_fmt))
 699                         goto post;
 700
 701                 if (output_color == COLOR_RGB) {
 702                         val |= V_WIN0_YUV2YUV_Y2R_EN(1);
 703                         if (win->colorspace == CSC_BT601) {
 704                                 /*
 705                                  * Win Y2Y moudle always use 10bit mode.
 706                                  */
 707                                 LOAD_CSC(vop_dev, Y2R,
 708                                          csc_y2r_bt601_full_10, i);
 709                         } else if (win->colorspace == CSC_BT709) {
 710                                 LOAD_CSC(vop_dev, Y2R,
 711                                          csc_y2r_bt709_full_10, i);
 712                         } else if (win->colorspace == CSC_BT2020) {
 713                                 val |= V_WIN0_YUV2YUV_EN(1);
 714                                 LOAD_CSC(vop_dev, Y2R, csc_y2r_bt2020, i);
 715                                 LOAD_CSC(vop_dev, R2R, csc_r2r_bt2020to709, i);
 716                         }
 717                 } else if (output_color == COLOR_YCBCR ||
 718                                 output_color == COLOR_YCBCR_BT709) {
 719                         if (!(IS_YUV(win->area[0].fmt_cfg) ||
 720                               win->area[0].yuyv_fmt)) {
 721                                 val |= V_WIN0_YUV2YUV_R2Y_EN(1);
 722                                 LOAD_CSC(vop_dev, R2Y, csc_r2y_bt709_full_10, i);
 723                         } else if (win->colorspace == CSC_BT2020) {
 724                                 val |= V_WIN0_YUV2YUV_EN(1) |
 725                                         V_WIN0_YUV2YUV_Y2R_EN(1) |
 726                                         V_WIN0_YUV2YUV_R2Y_EN(1);
 727                                 LOAD_CSC(vop_dev, Y2R, csc_y2r_bt2020, i);
 728                                 LOAD_CSC(vop_dev, R2R, csc_r2r_bt2020to709, i);
 729                                 LOAD_CSC(vop_dev, R2Y, csc_r2y_bt709_full_10, i);
 730                         }
 731                 } else if (output_color == COLOR_YCBCR_BT2020) {
 732                         if (!(IS_YUV(win->area[0].fmt_cfg) ||
 733                               win->area[0].yuyv_fmt)) {
 734                                 val |= V_WIN0_YUV2YUV_R2Y_EN(1) |
 735                                         V_WIN0_YUV2YUV_EN(1);
 736                                 LOAD_CSC(vop_dev, R2R, csc_r2r_bt709to2020, i);
 737                                 LOAD_CSC(vop_dev, R2Y, csc_r2y_bt2020, i);
 738                         } else if (win->colorspace == CSC_BT601 ||
 739                                         win->colorspace == CSC_BT709) {
 740                                 val |= V_WIN0_YUV2YUV_Y2R_EN(1) |
 741                                         V_WIN0_YUV2YUV_R2Y_EN(1) |
 742                                         V_WIN0_YUV2YUV_EN(1);
 743                                 LOAD_CSC(vop_dev, Y2R, csc_y2r_bt709_full_10, i);
 744                                 LOAD_CSC(vop_dev, R2R, csc_r2r_bt709to2020, i);
 745                                 LOAD_CSC(vop_dev, R2Y, csc_r2y_bt2020, i);
 746                         }
 747                 }
 748 post:
 749                 vop_msk_reg(vop_dev, YUV2YUV_WIN, val << shift);
 750         }
 751
 752         return output_color;
 753 }
 754
 755 /*
 756  * colorspace path:
 757  *      Input        Win csc            Post csc              Output
 758  * 1. YUV(2020)  --> bypass   ---+ Y2R->2020To709->R2Y --> YUV_OUTPUT(601/709)
 759  *    RGB        --> R2Y(709) __/
 760  *
 761  * 2. YUV(2020)  --> bypass   ---+       bypass        --> YUV_OUTPUT(2020)
 762  *    RGB        --> R2Y(709) __/
 763  *
 764  * 3. YUV(2020)  --> bypass   ---+    Y2R->2020To709   --> RGB_OUTPUT(709)
 765  *    RGB        --> R2Y(709) __/
 766  *
 767  * 4. YUV(601/709)-> bypass   ---+ Y2R->709To2020->R2Y --> YUV_OUTPUT(2020)
 768  *    RGB        --> R2Y(709) __/
 769  *
 770  * 5. YUV(601/709)-> bypass   ---+       bypass        --> YUV_OUTPUT(709)
 771  *    RGB        --> R2Y(709) __/
 772  *
 773  * 6. YUV(601/709)-> bypass   ---+       bypass        --> YUV_OUTPUT(601)
 774  *    RGB        --> R2Y(601) __/
 775  *
 776  * 7. YUV(601)   --> Y2R(601/mpeg)-+     bypass        --> RGB_OUTPUT(709)
 777  *    RGB        --> bypass   ____/
 778  *
 779  * 8. YUV(709)   --> Y2R(709/hd) --+     bypass        --> RGB_OUTPUT(709)
 780  *    RGB        --> bypass   ____/
 781  *
 782  * 9. RGB        --> bypass   --->    709To2020->R2Y   --> YUV_OUTPUT(2020)
 783  *
 784  * 10. RGB       --> R2Y(709) --->      bypass        --> YUV_OUTPUT(709)
 785  *
 786  * 11. RGB       --> R2Y(601) --->       bypass        --> YUV_OUTPUT(601)
 787  *
 788  * 12. RGB       --> bypass   --->       bypass        --> RGB_OUTPUT(709)
 789  */
 790 static int rk3228_vop_win_csc_cfg(struct rk_lcdc_driver *dev_drv)
 791 {
 792         struct vop_device *vop_dev =
 793             container_of(dev_drv, struct vop_device, driver);
 794         struct rk_lcdc_win *win;
 795         int output_color = dev_drv->output_color;
 796         int win_csc = COLOR_RGB;
 797         int r2y_mode = VOP_R2Y_CSC_BT709;
 798         int i;
 799
 800         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
 801                 win = dev_drv->win[i];
 802                 if (!win->state)
 803                         continue;
 804
 805                 if (IS_YUV(win->area[0].fmt_cfg)) {
 806                         if (win->colorspace == CSC_BT2020 &&
 807                             win_csc < COLOR_YCBCR_BT2020) {
 808                                 r2y_mode = VOP_R2Y_CSC_BT709;
 809                                 win_csc = COLOR_YCBCR_BT2020;
 810                         }
 811
 812                         if (win->colorspace == CSC_BT709 &&
 813                             win_csc < COLOR_YCBCR_BT709) {
 814                                 r2y_mode = VOP_R2Y_CSC_BT709;
 815                                 win_csc = COLOR_YCBCR_BT709;
 816                         }
 817
 818                         if (win->colorspace == CSC_BT601 &&
 819                             win_csc < COLOR_YCBCR) {
 820                                 r2y_mode = VOP_R2Y_CSC_BT709;
 821                                 win_csc = COLOR_YCBCR;
 822                         }
 823                 }
 824         }
 825
 826         if (win_csc == COLOR_RGB) {
 827                 if (output_color == COLOR_YCBCR_BT709) {
 828                         r2y_mode = VOP_R2Y_CSC_BT709;
 829                         win_csc = COLOR_YCBCR_BT709;
 830                 } else if (output_color == COLOR_YCBCR) {
 831                         r2y_mode = VOP_R2Y_CSC_BT601;
 832                         win_csc = COLOR_YCBCR;
 833                 }
 834         }
 835
 836         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
 837                 win = dev_drv->win[i];
 838                 if (!win->state)
 839                         continue;
 840
 841                 if (win_csc != COLOR_RGB && !IS_YUV(win->area[0].fmt_cfg))
 842                         vop_win_csc_mode(vop_dev, win, r2y_mode);
 843
 844                 if (IS_YUV(win->area[0].fmt_cfg)) {
 845                         if (win_csc == COLOR_YCBCR)
 846                                 vop_win_csc_mode(vop_dev, win,
 847                                                  VOP_Y2R_CSC_MPEG);
 848                         else if (win_csc == COLOR_YCBCR_BT709)
 849                                 vop_win_csc_mode(vop_dev, win, VOP_Y2R_CSC_HD);
 850                 }
 851         }
 852
 853         return win_csc;
 854 }
 855
 856 static int vop_post_csc_cfg(struct rk_lcdc_driver *dev_drv)
 857 {
 858         struct vop_device *vop_dev =
 859             container_of(dev_drv, struct vop_device, driver);
 860         int output_color = dev_drv->output_color;
 861         int win_csc = 0, overlay_mode = 0;
 862         u64 val;
 863
 864         if (VOP_CHIP(vop_dev) == VOP_RK322X) {
 865                 win_csc = rk3228_vop_win_csc_cfg(dev_drv);
 866         } else if (VOP_CHIP(vop_dev) == VOP_RK3399) {
 867                 win_csc = rk3399_vop_win_csc_cfg(dev_drv);
 868
 869                 /*
 870                  * RK3399 not support post csc config.
 871                  */
 872                 goto done;
 873         }
 874
 875         val = V_YUV2YUV_POST_Y2R_EN(0) | V_YUV2YUV_POST_EN(0) |
 876                 V_YUV2YUV_POST_R2Y_EN(0);
 877         /* Y2R */
 878         if (win_csc == COLOR_YCBCR && output_color == COLOR_YCBCR_BT2020) {
 879                 val |= V_YUV2YUV_POST_Y2R_EN(1);
 880                 vop_load_csc_table(vop_dev, POST_YUV2YUV_Y2R_COE,
 881                                    csc_y2r_bt709_full);
 882         }
 883         if (win_csc == COLOR_YCBCR_BT2020 &&
 884             output_color != COLOR_YCBCR_BT2020) {
 885                 val |= V_YUV2YUV_POST_Y2R_EN(1);
 886                 vop_load_csc_table(vop_dev, POST_YUV2YUV_Y2R_COE,
 887                                    csc_y2r_bt2020);
 888         }
 889
 890         /* R2R */
 891         if ((win_csc == COLOR_YCBCR ||
 892              win_csc == COLOR_YCBCR_BT709 ||
 893              win_csc == COLOR_RGB) && output_color == COLOR_YCBCR_BT2020) {
 894                 val |= V_YUV2YUV_POST_EN(1);
 895                 vop_load_csc_table(vop_dev, POST_YUV2YUV_3x3_COE,
 896                                    csc_r2r_bt709to2020);
 897         }
 898         if (win_csc == COLOR_YCBCR_BT2020 &&
 899             (output_color == COLOR_YCBCR ||
 900              output_color == COLOR_YCBCR_BT709 ||
 901              output_color == COLOR_RGB)) {
 902                 val |= V_YUV2YUV_POST_EN(1);
 903                 vop_load_csc_table(vop_dev, POST_YUV2YUV_3x3_COE,
 904                                    csc_r2r_bt2020to709);
 905         }
 906
 907         /* Y2R */
 908         if (output_color != COLOR_RGB) {
 909                 val |= V_YUV2YUV_POST_R2Y_EN(1);
 910
 911                 if (output_color == COLOR_YCBCR_BT2020)
 912                         vop_load_csc_table(vop_dev, POST_YUV2YUV_R2Y_COE,
 913                                            csc_r2y_bt2020);
 914                 else
 915                         vop_load_csc_table(vop_dev, POST_YUV2YUV_R2Y_COE,
 916                                            csc_r2y_bt709_full);
 917         }
 918
 919         DBG(1, "win_csc=%d output_color=%d val=%llx\n",
 920             win_csc, output_color, val);
 921         vop_msk_reg(vop_dev, YUV2YUV_POST, val);
 922 done:
 923         overlay_mode = (win_csc != COLOR_RGB) ? VOP_YUV_DOMAIN : VOP_RGB_DOMAIN;
 924         vop_msk_reg(vop_dev, SYS_CTRL, V_OVERLAY_MODE(overlay_mode));
 925
 926         return 0;
 927 }
 928
 929 static int vop_post_cfg(struct rk_lcdc_driver *dev_drv)
 930 {
 931         struct vop_device *vop_dev =
 932             container_of(dev_drv, struct vop_device, driver);
 933         struct rk_screen *screen = dev_drv->cur_screen;
 934         u16 x_res = screen->mode.xres;
 935         u16 y_res = screen->mode.yres;
 936         u64 val;
 937         u16 h_total, v_total;
 938         u16 post_hsd_en, post_vsd_en;
 939         u16 post_dsp_hact_st, post_dsp_hact_end;
 940         u16 post_dsp_vact_st, post_dsp_vact_end;
 941         u16 post_dsp_vact_st_f1, post_dsp_vact_end_f1;
 942         u16 post_h_fac, post_v_fac;
 943
 944         screen->post_dsp_stx = x_res * (100 - dev_drv->overscan.left) / 200;
 945         screen->post_dsp_sty = y_res * (100 - dev_drv->overscan.top) / 200;
 946         screen->post_xsize = x_res *
 947             (dev_drv->overscan.left + dev_drv->overscan.right) / 200;
 948         screen->post_ysize = y_res *
 949             (dev_drv->overscan.top + dev_drv->overscan.bottom) / 200;
 950
 951         h_total = screen->mode.hsync_len + screen->mode.left_margin +
 952             x_res + screen->mode.right_margin;
 953         v_total = screen->mode.vsync_len + screen->mode.upper_margin +
 954             y_res + screen->mode.lower_margin;
 955
 956         if (screen->post_dsp_stx + screen->post_xsize > x_res) {
 957                 dev_warn(vop_dev->dev, "post:stx[%d]+xsize[%d]>x_res[%d]\n",
 958                          screen->post_dsp_stx, screen->post_xsize, x_res);
 959                 screen->post_dsp_stx = x_res - screen->post_xsize;
 960         }
 961         if (screen->x_mirror == 0) {
 962                 post_dsp_hact_st = screen->post_dsp_stx +
 963                     screen->mode.hsync_len + screen->mode.left_margin;
 964                 post_dsp_hact_end = post_dsp_hact_st + screen->post_xsize;
 965         } else {
 966                 post_dsp_hact_end = h_total - screen->mode.right_margin -
 967                     screen->post_dsp_stx;
 968                 post_dsp_hact_st = post_dsp_hact_end - screen->post_xsize;
 969         }
 970         if ((screen->post_xsize < x_res) && (screen->post_xsize != 0)) {
 971                 post_hsd_en = 1;
 972                 post_h_fac =
 973                     GET_SCALE_FACTOR_BILI_DN(x_res, screen->post_xsize);
 974         } else {
 975                 post_hsd_en = 0;
 976                 post_h_fac = 0x1000;
 977         }
 978
 979         if (screen->post_dsp_sty + screen->post_ysize > y_res) {
 980                 dev_warn(vop_dev->dev, "post:sty[%d]+ysize[%d]> y_res[%d]\n",
 981                          screen->post_dsp_sty, screen->post_ysize, y_res);
 982                 screen->post_dsp_sty = y_res - screen->post_ysize;
 983         }
 984
 985         if ((screen->post_ysize < y_res) && (screen->post_ysize != 0)) {
 986                 post_vsd_en = 1;
 987                 post_v_fac = GET_SCALE_FACTOR_BILI_DN(y_res,
 988                                                       screen->post_ysize);
 989         } else {
 990                 post_vsd_en = 0;
 991                 post_v_fac = 0x1000;
 992         }
 993
 994         if (screen->mode.vmode & FB_VMODE_INTERLACED) {
 995                 post_dsp_vact_st = screen->post_dsp_sty / 2 +
 996                                         screen->mode.vsync_len +
 997                                         screen->mode.upper_margin;
 998                 post_dsp_vact_end = post_dsp_vact_st +
 999                                         screen->post_ysize / 2;
1000
1001                 post_dsp_vact_st_f1 = screen->mode.vsync_len +
1002                                         screen->mode.upper_margin +
1003                                         y_res / 2 +
1004                                         screen->mode.lower_margin +
1005                                         screen->mode.vsync_len +
1006                                         screen->mode.upper_margin +
1007                                         screen->post_dsp_sty / 2 +
1008                                         1;
1009                 post_dsp_vact_end_f1 = post_dsp_vact_st_f1 +
1010                                         screen->post_ysize / 2;
1011         } else {
1012                 if (screen->y_mirror == 0) {
1013                         post_dsp_vact_st = screen->post_dsp_sty +
1014                             screen->mode.vsync_len +
1015                             screen->mode.upper_margin;
1016                         post_dsp_vact_end = post_dsp_vact_st +
1017                                 screen->post_ysize;
1018                 } else {
1019                         post_dsp_vact_end = v_total -
1020                                 screen->mode.lower_margin -
1021                             screen->post_dsp_sty;
1022                         post_dsp_vact_st = post_dsp_vact_end -
1023                                 screen->post_ysize;
1024                 }
1025                 post_dsp_vact_st_f1 = 0;
1026                 post_dsp_vact_end_f1 = 0;
1027         }
1028         DBG(1, "post:xsize=%d,ysize=%d,xpos=%d",
1029             screen->post_xsize, screen->post_ysize, screen->xpos);
1030         DBG(1, ",ypos=%d,hsd_en=%d,h_fac=%d,vsd_en=%d,v_fac=%d\n",
1031             screen->ypos, post_hsd_en, post_h_fac, post_vsd_en, post_v_fac);
1032         val = V_DSP_HACT_END_POST(post_dsp_hact_end) |
1033             V_DSP_HACT_ST_POST(post_dsp_hact_st);
1034         vop_msk_reg(vop_dev, POST_DSP_HACT_INFO, val);
1035
1036         val = V_DSP_VACT_END_POST(post_dsp_vact_end) |
1037             V_DSP_VACT_ST_POST(post_dsp_vact_st);
1038         vop_msk_reg(vop_dev, POST_DSP_VACT_INFO, val);
1039
1040         val = V_POST_HS_FACTOR_YRGB(post_h_fac) |
1041             V_POST_VS_FACTOR_YRGB(post_v_fac);
1042         vop_msk_reg(vop_dev, POST_SCL_FACTOR_YRGB, val);
1043         val = V_DSP_VACT_END_POST(post_dsp_vact_end_f1) |
1044             V_DSP_VACT_ST_POST(post_dsp_vact_st_f1);
1045         vop_msk_reg(vop_dev, POST_DSP_VACT_INFO_F1, val);
1046         val = V_POST_HOR_SD_EN(post_hsd_en) | V_POST_VER_SD_EN(post_vsd_en);
1047         vop_msk_reg(vop_dev, POST_SCL_CTRL, val);
1048
1049         vop_post_csc_cfg(dev_drv);
1050
1051         return 0;
1052 }
1053
1054 static int vop_clr_key_cfg(struct rk_lcdc_driver *dev_drv)
1055 {
1056         struct vop_device *vop_dev =
1057             container_of(dev_drv, struct vop_device, driver);
1058         struct rk_lcdc_win *win;
1059         u32 colorkey_r, colorkey_g, colorkey_b;
1060         int i, key_val;
1061
1062         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
1063                 win = dev_drv->win[i];
1064                 key_val = win->color_key_val;
1065                 colorkey_r = (key_val & 0xff) << 2;
1066                 colorkey_g = ((key_val >> 8) & 0xff) << 12;
1067                 colorkey_b = ((key_val >> 16) & 0xff) << 22;
1068                 /* color key dither 565/888->aaa */
1069                 key_val = colorkey_r | colorkey_g | colorkey_b;
1070                 switch (i) {
1071                 case 0:
1072                         vop_writel(vop_dev, WIN0_COLOR_KEY, key_val);
1073                         break;
1074                 case 1:
1075                         vop_writel(vop_dev, WIN1_COLOR_KEY, key_val);
1076                         break;
1077                 case 2:
1078                         vop_writel(vop_dev, WIN2_COLOR_KEY, key_val);
1079                         break;
1080                 case 3:
1081                         vop_writel(vop_dev, WIN3_COLOR_KEY, key_val);
1082                         break;
1083                 default:
1084                         pr_info("%s:un support win num:%d\n",
1085                                 __func__, i);
1086                         break;
1087                 }
1088         }
1089         return 0;
1090 }
1091
1092 static int vop_alpha_cfg(struct rk_lcdc_driver *dev_drv, int win_id)
1093 {
1094         struct vop_device *vop_dev =
1095             container_of(dev_drv, struct vop_device, driver);
1096         struct rk_lcdc_win *win = dev_drv->win[win_id];
1097         struct alpha_config alpha_config;
1098         u64 val;
1099         int ppixel_alpha = 0, global_alpha = 0, i;
1100         u32 src_alpha_ctl = 0, dst_alpha_ctl = 0;
1101         int alpha_en = 1;
1102
1103         memset(&alpha_config, 0, sizeof(struct alpha_config));
1104         for (i = 0; i < win->area_num; i++) {
1105                 ppixel_alpha |= ((win->area[i].format == ARGB888) ||
1106                                  (win->area[i].format == FBDC_ARGB_888) ||
1107                                  (win->area[i].format == FBDC_ABGR_888) ||
1108                                  (win->area[i].format == ABGR888)) ? 1 : 0;
1109         }
1110
1111         global_alpha = (win->g_alpha_val == 0) ? 0 : 1;
1112
1113         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
1114                 if (!dev_drv->win[i]->state)
1115                         continue;
1116                 if (win->z_order > dev_drv->win[i]->z_order)
1117                         break;
1118         }
1119
1120         /*
1121          * The bottom layer not support ppixel_alpha mode.
1122          */
1123         if (i == dev_drv->lcdc_win_num)
1124                 ppixel_alpha = 0;
1125         alpha_config.src_global_alpha_val = win->g_alpha_val;
1126         win->alpha_mode = AB_SRC_OVER;
1127
1128         switch (win->alpha_mode) {
1129         case AB_USER_DEFINE:
1130                 break;
1131         case AB_CLEAR:
1132                 alpha_config.src_factor_mode = AA_ZERO;
1133                 alpha_config.dst_factor_mode = AA_ZERO;
1134                 break;
1135         case AB_SRC:
1136                 alpha_config.src_factor_mode = AA_ONE;
1137                 alpha_config.dst_factor_mode = AA_ZERO;
1138                 break;
1139         case AB_DST:
1140                 alpha_config.src_factor_mode = AA_ZERO;
1141                 alpha_config.dst_factor_mode = AA_ONE;
1142                 break;
1143         case AB_SRC_OVER:
1144                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1145                 if (global_alpha)
1146                         alpha_config.src_factor_mode = AA_SRC_GLOBAL;
1147                 else
1148                         alpha_config.src_factor_mode = AA_ONE;
1149                 alpha_config.dst_factor_mode = AA_SRC_INVERSE;
1150                 break;
1151         case AB_DST_OVER:
1152                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1153                 alpha_config.src_factor_mode = AA_SRC_INVERSE;
1154                 alpha_config.dst_factor_mode = AA_ONE;
1155                 break;
1156         case AB_SRC_IN:
1157                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1158                 alpha_config.src_factor_mode = AA_SRC;
1159                 alpha_config.dst_factor_mode = AA_ZERO;
1160                 break;
1161         case AB_DST_IN:
1162                 alpha_config.src_factor_mode = AA_ZERO;
1163                 alpha_config.dst_factor_mode = AA_SRC;
1164                 break;
1165         case AB_SRC_OUT:
1166                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1167                 alpha_config.src_factor_mode = AA_SRC_INVERSE;
1168                 alpha_config.dst_factor_mode = AA_ZERO;
1169                 break;
1170         case AB_DST_OUT:
1171                 alpha_config.src_factor_mode = AA_ZERO;
1172                 alpha_config.dst_factor_mode = AA_SRC_INVERSE;
1173                 break;
1174         case AB_SRC_ATOP:
1175                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1176                 alpha_config.src_factor_mode = AA_SRC;
1177                 alpha_config.dst_factor_mode = AA_SRC_INVERSE;
1178                 break;
1179         case AB_DST_ATOP:
1180                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1181                 alpha_config.src_factor_mode = AA_SRC_INVERSE;
1182                 alpha_config.dst_factor_mode = AA_SRC;
1183                 break;
1184         case XOR:
1185                 alpha_config.src_color_mode = AA_SRC_PRE_MUL;
1186                 alpha_config.src_factor_mode = AA_SRC_INVERSE;
1187                 alpha_config.dst_factor_mode = AA_SRC_INVERSE;
1188                 break;
1189         case AB_SRC_OVER_GLOBAL:
1190                 alpha_config.src_global_alpha_mode = AA_PER_PIX_GLOBAL;
1191                 alpha_config.src_color_mode = AA_SRC_NO_PRE_MUL;
1192                 alpha_config.src_factor_mode = AA_SRC_GLOBAL;
1193                 alpha_config.dst_factor_mode = AA_SRC_INVERSE;
1194                 break;
1195         default:
1196                 pr_err("alpha mode error\n");
1197                 break;
1198         }
1199         if ((ppixel_alpha == 1) && (global_alpha == 1))
1200                 alpha_config.src_global_alpha_mode = AA_PER_PIX_GLOBAL;
1201         else if (ppixel_alpha == 1)
1202                 alpha_config.src_global_alpha_mode = AA_PER_PIX;
1203         else if (global_alpha == 1)
1204                 alpha_config.src_global_alpha_mode = AA_GLOBAL;
1205         else
1206                 alpha_en = 0;
1207         alpha_config.src_alpha_mode = AA_STRAIGHT;
1208         alpha_config.src_alpha_cal_m0 = AA_NO_SAT;
1209
1210         switch (win_id) {
1211         case 0:
1212                 src_alpha_ctl = 0x60;
1213                 dst_alpha_ctl = 0x64;
1214                 break;
1215         case 1:
1216                 src_alpha_ctl = 0xa0;
1217                 dst_alpha_ctl = 0xa4;
1218                 break;
1219         case 2:
1220                 src_alpha_ctl = 0xdc;
1221                 dst_alpha_ctl = 0xec;
1222                 break;
1223         case 3:
1224                 src_alpha_ctl = 0x12c;
1225                 dst_alpha_ctl = 0x13c;
1226                 break;
1227         case 4:
1228                 src_alpha_ctl = 0x160;
1229                 dst_alpha_ctl = 0x164;
1230                 break;
1231         }
1232         val = V_WIN0_DST_FACTOR_MODE(alpha_config.dst_factor_mode);
1233         vop_msk_reg(vop_dev, dst_alpha_ctl, val);
1234         val = V_WIN0_SRC_ALPHA_EN(alpha_en) |
1235             V_WIN0_SRC_COLOR_MODE(alpha_config.src_color_mode) |
1236             V_WIN0_SRC_ALPHA_MODE(alpha_config.src_alpha_mode) |
1237             V_WIN0_SRC_BLEND_MODE(alpha_config.src_global_alpha_mode) |
1238             V_WIN0_SRC_ALPHA_CAL_MODE(alpha_config.src_alpha_cal_m0) |
1239             V_WIN0_SRC_FACTOR_MODE(alpha_config.src_factor_mode) |
1240             V_WIN0_SRC_GLOBAL_ALPHA(alpha_config.src_global_alpha_val);
1241
1242         vop_msk_reg(vop_dev, src_alpha_ctl, val);
1243
1244         return 0;
1245 }
1246
1247 static int vop_axi_gather_cfg(struct vop_device *vop_dev,
1248                               struct rk_lcdc_win *win)
1249 {
1250         u64 val;
1251         u16 yrgb_gather_num = 3;
1252         u16 cbcr_gather_num = 1;
1253
1254         switch (win->area[0].format) {
1255         case ARGB888:
1256         case XBGR888:
1257         case ABGR888:
1258         case FBDC_ARGB_888:
1259         case FBDC_RGBX_888:
1260         case FBDC_ABGR_888:
1261                 yrgb_gather_num = 3;
1262                 break;
1263         case RGB888:
1264         case RGB565:
1265         case FBDC_RGB_565:
1266                 yrgb_gather_num = 2;
1267                 break;
1268         case YUV444:
1269         case YUV422:
1270         case YUV420:
1271         case YUV420_A:
1272         case YUV422_A:
1273         case YUV444_A:
1274         case YUV420_NV21:
1275         case YUYV420:
1276         case UYVY420:
1277                 yrgb_gather_num = 1;
1278                 cbcr_gather_num = 2;
1279                 break;
1280         case YUYV422:
1281         case UYVY422:
1282                 yrgb_gather_num = 2;
1283                 cbcr_gather_num = 2;
1284                 break;
1285         default:
1286                 dev_err(vop_dev->driver.dev, "%s:un supported format[%d]\n",
1287                         __func__, win->area[0].format);
1288                 return -EINVAL;
1289         }
1290
1291         if ((win->id == VOP_WIN0) || (win->id == VOP_WIN1)) {
1292                 val = V_WIN0_YRGB_AXI_GATHER_EN(1) |
1293                         V_WIN0_CBR_AXI_GATHER_EN(1) |
1294                         V_WIN0_YRGB_AXI_GATHER_NUM(yrgb_gather_num) |
1295                         V_WIN0_CBR_AXI_GATHER_NUM(cbcr_gather_num);
1296                 vop_msk_reg(vop_dev, WIN0_CTRL1 + (win->id * 0x40), val);
1297         } else if ((win->id == VOP_WIN2) || (win->id == VOP_WIN3)) {
1298                 val = V_WIN2_AXI_GATHER_EN(1) |
1299                         V_WIN2_AXI_GATHER_NUM(yrgb_gather_num);
1300                 vop_msk_reg(vop_dev, WIN2_CTRL1 + ((win->id - 2) * 0x50), val);
1301         } else if (win->id == VOP_HWC) {
1302                 val = V_HWC_AXI_GATHER_EN(1) |
1303                         V_HWC_AXI_GATHER_NUM(yrgb_gather_num);
1304                 vop_msk_reg(vop_dev, HWC_CTRL1, val);
1305         }
1306         return 0;
1307 }
1308
1309 static int vop_fbdc_reg_update(struct vop_device *vop_dev, int win_id)
1310 {
1311         struct rk_lcdc_win *win = vop_dev->driver.win[win_id];
1312         u64 val;
1313
1314         val = V_VOP_FBDC_WIN_SEL(win_id) |
1315                 V_AFBCD_HREG_PIXEL_PACKING_FMT(win->area[0].fbdc_fmt_cfg) |
1316                 V_AFBCD_HREG_BLOCK_SPLIT(win->area[0].fbdc_cor_en);
1317         vop_msk_reg(vop_dev, AFBCD0_CTRL, val);
1318
1319         val = V_AFBCD_HREG_PIC_WIDTH(win->area[0].fbdc_mb_width - 1) |
1320                 V_AFBCD_HREG_PIC_HEIGHT(win->area[0].fbdc_mb_height - 1);
1321         vop_msk_reg(vop_dev, AFBCD0_PIC_SIZE, val);
1322
1323         return 0;
1324 }
1325
1326 static int vop_init_fbdc_config(struct vop_device *vop_dev, int win_id)
1327 {
1328         struct rk_lcdc_driver *vop_drv = &vop_dev->driver;
1329         struct rk_lcdc_win *win = vop_drv->win[win_id];
1330         struct rk_screen *screen = vop_drv->cur_screen;
1331
1332         if (screen->mode.flag & FB_VMODE_INTERLACED) {
1333                 dev_err(vop_dev->dev, "unsupport fbdc+interlace!\n");
1334                 return 0;
1335         }
1336
1337         if (VOP_CHIP(vop_dev) != VOP_RK3399) {
1338                 pr_err("soc: 0x%08x not support FBDC\n", VOP_CHIP(vop_dev));
1339                 return 0;
1340         }
1341
1342         win->area[0].fbdc_mb_width = win->area[0].xvir;
1343         win->area[0].fbdc_mb_height = win->area[0].yact;
1344         win->area[0].fbdc_cor_en = 0; /* hreg_block_split */
1345         win->area[0].fbdc_fmt_cfg |= AFBDC_YUV_COLOR_TRANSFORM << 4;
1346
1347         return 0;
1348 }
1349
1350 static int vop_win_0_1_reg_update(struct rk_lcdc_driver *dev_drv, int win_id)
1351 {
1352         struct vop_device *vop_dev =
1353             container_of(dev_drv, struct vop_device, driver);
1354         struct rk_lcdc_win *win = dev_drv->win[win_id];
1355         u64 val;
1356         u32 off;
1357         int format;
1358         struct rk_win_property *win_property =
1359                                 &dev_drv->win[win_id]->property;
1360
1361         off = win_id * 0x40;
1362
1363         if (win->state == 1) {
1364                 if (!(win_property->feature & SUPPORT_HW_EXIST)) {
1365                         pr_err("vop[%d] win[%d] hardware unsupport\n",
1366                                vop_dev->id, win_id);
1367                         return 0;
1368                 }
1369                 vop_axi_gather_cfg(vop_dev, win);
1370                 if (win->area[0].fbdc_en)
1371                         vop_fbdc_reg_update(vop_dev, win_id);
1372                 /*
1373                  * rk322x have a bug on windows 0 and 1:
1374                  *
1375                  * When switch win format from RGB to YUV, would flash
1376                  * some green lines on the top of the windows.
1377                  *
1378                  * Use bg_en show one blank frame to skip the error frame.
1379                  */
1380                 if (IS_YUV(win->area[0].fmt_cfg)) {
1381                         val = vop_readl(vop_dev, WIN0_CTRL0);
1382                         format = (val & MASK(WIN0_DATA_FMT)) >> 1;
1383
1384                         if (!IS_YUV(format)) {
1385                                 if (dev_drv->overlay_mode == VOP_YUV_DOMAIN) {
1386                                         val = V_WIN0_DSP_BG_RED(0x200) |
1387                                                 V_WIN0_DSP_BG_GREEN(0x40) |
1388                                                 V_WIN0_DSP_BG_BLUE(0x200) |
1389                                                 V_WIN0_BG_EN(1);
1390                                         vop_msk_reg(vop_dev, WIN0_DSP_BG + off,
1391                                                     val);
1392                                 } else {
1393                                         val = V_WIN0_DSP_BG_RED(0) |
1394                                                 V_WIN0_DSP_BG_GREEN(0) |
1395                                                 V_WIN0_DSP_BG_BLUE(0) |
1396                                                 V_WIN0_BG_EN(1);
1397                                         vop_msk_reg(vop_dev, WIN0_DSP_BG + off,
1398                                                     val);
1399                                 }
1400                         } else {
1401                                 val = V_WIN0_BG_EN(0);
1402                                 vop_msk_reg(vop_dev, WIN0_DSP_BG + off, val);
1403                         }
1404                 } else {
1405                         val = V_WIN0_BG_EN(0);
1406                         vop_msk_reg(vop_dev, WIN0_DSP_BG + off, val);
1407                 }
1408
1409                 val = V_WIN0_EN(win->state) |
1410                         V_WIN0_DATA_FMT(win->area[0].fmt_cfg) |
1411                         V_WIN0_FMT_10(win->fmt_10) |
1412                         V_WIN0_LB_MODE(win->win_lb_mode) |
1413                         V_WIN0_RB_SWAP(win->area[0].swap_rb) |
1414                         V_WIN0_X_MIR_EN(win->xmirror) |
1415                         V_WIN0_Y_MIR_EN(win->ymirror) |
1416                         V_WIN0_UV_SWAP(win->area[0].swap_uv);
1417                 if (VOP_CHIP(vop_dev) == VOP_RK3399)
1418                         val |= V_WIN0_YUYV(win->area[0].yuyv_fmt);
1419                 vop_msk_reg(vop_dev, WIN0_CTRL0 + off, val);
1420                 val = V_WIN0_BIC_COE_SEL(win->bic_coe_el) |
1421                     V_WIN0_VSD_YRGB_GT4(win->vsd_yrgb_gt4) |
1422                     V_WIN0_VSD_YRGB_GT2(win->vsd_yrgb_gt2) |
1423                     V_WIN0_VSD_CBR_GT4(win->vsd_cbr_gt4) |
1424                     V_WIN0_VSD_CBR_GT2(win->vsd_cbr_gt2) |
1425                     V_WIN0_YRGB_HOR_SCL_MODE(win->yrgb_hor_scl_mode) |
1426                     V_WIN0_YRGB_VER_SCL_MODE(win->yrgb_ver_scl_mode) |
1427                     V_WIN0_YRGB_HSD_MODE(win->yrgb_hsd_mode) |
1428                     V_WIN0_YRGB_VSU_MODE(win->yrgb_vsu_mode) |
1429                     V_WIN0_YRGB_VSD_MODE(win->yrgb_vsd_mode) |
1430                     V_WIN0_CBR_HOR_SCL_MODE(win->cbr_hor_scl_mode) |
1431                     V_WIN0_CBR_VER_SCL_MODE(win->cbr_ver_scl_mode) |
1432                     V_WIN0_CBR_HSD_MODE(win->cbr_hsd_mode) |
1433                     V_WIN0_CBR_VSU_MODE(win->cbr_vsu_mode) |
1434                     V_WIN0_CBR_VSD_MODE(win->cbr_vsd_mode);
1435                 vop_msk_reg(vop_dev, WIN0_CTRL1 + off, val);
1436                 val = V_WIN0_VIR_STRIDE(win->area[0].y_vir_stride) |
1437                     V_WIN0_VIR_STRIDE_UV(win->area[0].uv_vir_stride);
1438                 vop_writel(vop_dev, WIN0_VIR + off, val);
1439                 val = V_WIN0_ACT_WIDTH(win->area[0].xact - 1) |
1440                     V_WIN0_ACT_HEIGHT(win->area[0].yact - 1);
1441                 vop_writel(vop_dev, WIN0_ACT_INFO + off, val);
1442
1443                 val = V_WIN0_DSP_WIDTH(win->area[0].xsize - 1) |
1444                     V_WIN0_DSP_HEIGHT(win->area[0].ysize - 1);
1445                 vop_writel(vop_dev, WIN0_DSP_INFO + off, val);
1446
1447                 val = V_WIN0_DSP_XST(win->area[0].dsp_stx) |
1448                     V_WIN0_DSP_YST(win->area[0].dsp_sty);
1449                 vop_writel(vop_dev, WIN0_DSP_ST + off, val);
1450
1451                 val = V_WIN0_HS_FACTOR_YRGB(win->scale_yrgb_x) |
1452                     V_WIN0_VS_FACTOR_YRGB(win->scale_yrgb_y);
1453                 vop_writel(vop_dev, WIN0_SCL_FACTOR_YRGB + off, val);
1454
1455                 val = V_WIN0_HS_FACTOR_CBR(win->scale_cbcr_x) |
1456                     V_WIN0_VS_FACTOR_CBR(win->scale_cbcr_y);
1457                 vop_writel(vop_dev, WIN0_SCL_FACTOR_CBR + off, val);
1458         } else {
1459                 val = V_WIN0_EN(win->state);
1460                 vop_msk_reg(vop_dev, WIN0_CTRL0 + off, val);
1461         }
1462
1463         return 0;
1464 }
1465
1466 static int area_xst(struct rk_lcdc_win *win, int area_num)
1467 {
1468         struct rk_lcdc_win_area area_temp;
1469         int i, j;
1470
1471         for (i = 0; i < area_num; i++) {
1472                 for (j = i + 1; j < area_num; j++) {
1473                         if (win->area[i].dsp_stx >  win->area[j].dsp_stx) {
1474                                 memcpy(&area_temp, &win->area[i],
1475                                        sizeof(struct rk_lcdc_win_area));
1476                                 memcpy(&win->area[i], &win->area[j],
1477                                        sizeof(struct rk_lcdc_win_area));
1478                                 memcpy(&win->area[j], &area_temp,
1479                                        sizeof(struct rk_lcdc_win_area));
1480                         }
1481                 }
1482         }
1483
1484         return 0;
1485 }
1486
1487 static int vop_win_2_3_reg_update(struct rk_lcdc_driver *dev_drv, int win_id)
1488 {
1489         struct vop_device *vop_dev =
1490                         container_of(dev_drv, struct vop_device, driver);
1491         struct rk_lcdc_win *win = dev_drv->win[win_id];
1492         unsigned int off;
1493         u64 val;
1494         struct rk_win_property *win_property =
1495                                 &dev_drv->win[win_id]->property;
1496
1497         off = (win_id - 2) * 0x50;
1498         area_xst(win, win->area_num);
1499
1500         if (win->state == 1) {
1501                 if (!(win_property->feature & SUPPORT_HW_EXIST)) {
1502                         pr_err("vop[%d] win[%d] hardware unsupport\n",
1503                                vop_dev->id, win_id);
1504                         return 0;
1505                 }
1506                 vop_axi_gather_cfg(vop_dev, win);
1507                 if (win->area[0].fbdc_en)
1508                         vop_fbdc_reg_update(vop_dev, win_id);
1509                 val = V_WIN2_EN(1) | V_WIN1_CSC_MODE(win->csc_mode);
1510                 vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1511                 /* area 0 */
1512                 if (win->area[0].state == 1) {
1513                         val = V_WIN2_MST0_EN(win->area[0].state) |
1514                             V_WIN2_DATA_FMT0(win->area[0].fmt_cfg) |
1515                             V_WIN2_RB_SWAP0(win->area[0].swap_rb);
1516                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1517
1518                         val = V_WIN2_VIR_STRIDE0(win->area[0].y_vir_stride);
1519                         vop_msk_reg(vop_dev, WIN2_VIR0_1 + off, val);
1520
1521                         val = V_WIN2_DSP_WIDTH0(win->area[0].xsize - 1) |
1522                             V_WIN2_DSP_HEIGHT0(win->area[0].ysize - 1);
1523                         vop_writel(vop_dev, WIN2_DSP_INFO0 + off, val);
1524                         val = V_WIN2_DSP_XST0(win->area[0].dsp_stx) |
1525                             V_WIN2_DSP_YST0(win->area[0].dsp_sty);
1526                         vop_writel(vop_dev, WIN2_DSP_ST0 + off, val);
1527                 } else {
1528                         val = V_WIN2_MST0_EN(0);
1529                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1530                 }
1531                 /* area 1 */
1532                 if (win->area[1].state == 1) {
1533                         val = V_WIN2_MST1_EN(win->area[1].state) |
1534                             V_WIN2_DATA_FMT1(win->area[1].fmt_cfg) |
1535                             V_WIN2_RB_SWAP1(win->area[1].swap_rb);
1536                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1537
1538                         val = V_WIN2_VIR_STRIDE1(win->area[1].y_vir_stride);
1539                         vop_msk_reg(vop_dev, WIN2_VIR0_1 + off, val);
1540
1541                         val = V_WIN2_DSP_WIDTH1(win->area[1].xsize - 1) |
1542                             V_WIN2_DSP_HEIGHT1(win->area[1].ysize - 1);
1543                         vop_writel(vop_dev, WIN2_DSP_INFO1 + off, val);
1544                         val = V_WIN2_DSP_XST1(win->area[1].dsp_stx) |
1545                             V_WIN2_DSP_YST1(win->area[1].dsp_sty);
1546                         vop_writel(vop_dev, WIN2_DSP_ST1 + off, val);
1547                 } else {
1548                         val = V_WIN2_MST1_EN(0);
1549                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1550                 }
1551                 /* area 2 */
1552                 if (win->area[2].state == 1) {
1553                         val = V_WIN2_MST2_EN(win->area[2].state) |
1554                             V_WIN2_DATA_FMT2(win->area[2].fmt_cfg) |
1555                             V_WIN2_RB_SWAP2(win->area[2].swap_rb);
1556                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1557
1558                         val = V_WIN2_VIR_STRIDE2(win->area[2].y_vir_stride);
1559                         vop_msk_reg(vop_dev, WIN2_VIR2_3 + off, val);
1560
1561                         val = V_WIN2_DSP_WIDTH2(win->area[2].xsize - 1) |
1562                             V_WIN2_DSP_HEIGHT2(win->area[2].ysize - 1);
1563                         vop_writel(vop_dev, WIN2_DSP_INFO2 + off, val);
1564                         val = V_WIN2_DSP_XST2(win->area[2].dsp_stx) |
1565                             V_WIN2_DSP_YST2(win->area[2].dsp_sty);
1566                         vop_writel(vop_dev, WIN2_DSP_ST2 + off, val);
1567                 } else {
1568                         val = V_WIN2_MST2_EN(0);
1569                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1570                 }
1571                 /* area 3 */
1572                 if (win->area[3].state == 1) {
1573                         val = V_WIN2_MST3_EN(win->area[3].state) |
1574                             V_WIN2_DATA_FMT3(win->area[3].fmt_cfg) |
1575                             V_WIN2_RB_SWAP3(win->area[3].swap_rb);
1576                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1577
1578                         val = V_WIN2_VIR_STRIDE3(win->area[3].y_vir_stride);
1579                         vop_msk_reg(vop_dev, WIN2_VIR2_3 + off, val);
1580
1581                         val = V_WIN2_DSP_WIDTH3(win->area[3].xsize - 1) |
1582                             V_WIN2_DSP_HEIGHT3(win->area[3].ysize - 1);
1583                         vop_writel(vop_dev, WIN2_DSP_INFO3 + off, val);
1584                         val = V_WIN2_DSP_XST3(win->area[3].dsp_stx) |
1585                             V_WIN2_DSP_YST3(win->area[3].dsp_sty);
1586                         vop_writel(vop_dev, WIN2_DSP_ST3 + off, val);
1587                 } else {
1588                         val = V_WIN2_MST3_EN(0);
1589                         vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1590                 }
1591         } else {
1592                 val = V_WIN2_EN(win->state) | V_WIN2_MST0_EN(0) |
1593                     V_WIN2_MST1_EN(0) | V_WIN2_MST2_EN(0) | V_WIN2_MST3_EN(0);
1594                 vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
1595         }
1596
1597         return 0;
1598 }
1599
1600 static int vop_hwc_reg_update(struct rk_lcdc_driver *dev_drv, int win_id)
1601 {
1602         struct vop_device *vop_dev =
1603             container_of(dev_drv, struct vop_device, driver);
1604         struct rk_lcdc_win *win = dev_drv->win[win_id];
1605         unsigned int hwc_size = 0;
1606         u64 val;
1607
1608         if ((win->area[0].xsize == 32) && (win->area[0].ysize == 32)) {
1609                 hwc_size = 0;
1610         } else if ((win->area[0].xsize == 64) && (win->area[0].ysize == 64)) {
1611                 hwc_size = 1;
1612         } else if ((win->area[0].xsize == 96) && (win->area[0].ysize == 96)) {
1613                 hwc_size = 2;
1614         } else if ((win->area[0].xsize == 128) &&
1615                    (win->area[0].ysize == 128)) {
1616                 hwc_size = 3;
1617         } else {
1618                 dev_err(vop_dev->dev, "un supported hwc size[%dx%d]!\n",
1619                                 win->area[0].xsize, win->area[0].ysize);
1620                 return -EINVAL;
1621         }
1622
1623         if (win->state == 1) {
1624                 vop_axi_gather_cfg(vop_dev, win);
1625                 val = V_HWC_EN(1) | V_HWC_DATA_FMT(win->area[0].fmt_cfg) |
1626                     V_HWC_RB_SWAP(win->area[0].swap_rb);
1627                 vop_msk_reg(vop_dev, HWC_CTRL0, val);
1628
1629                 val = V_HWC_SIZE(hwc_size);
1630                 vop_msk_reg(vop_dev, HWC_CTRL0, val);
1631
1632                 val = V_HWC_DSP_XST(win->area[0].dsp_stx) |
1633                     V_HWC_DSP_YST(win->area[0].dsp_sty);
1634                 vop_msk_reg(vop_dev, HWC_DSP_ST, val);
1635         } else {
1636                 val = V_HWC_EN(win->state);
1637                 vop_msk_reg(vop_dev, HWC_CTRL0, val);
1638         }
1639
1640         return 0;
1641 }
1642
1643 static int vop_layer_update_regs(struct vop_device *vop_dev,
1644                                  struct rk_lcdc_win *win)
1645 {
1646         struct rk_lcdc_driver *dev_drv = &vop_dev->driver;
1647
1648         if (likely(vop_dev->clk_on)) {
1649                 vop_msk_reg(vop_dev, SYS_CTRL,
1650                             V_VOP_STANDBY_EN(vop_dev->standby));
1651                 if ((win->id == VOP_WIN0) || (win->id == VOP_WIN1))
1652                         vop_win_0_1_reg_update(dev_drv, win->id);
1653                 else if ((win->id == VOP_WIN2) || (win->id == VOP_WIN3))
1654                         vop_win_2_3_reg_update(dev_drv, win->id);
1655                 else if (win->id == VOP_HWC)
1656                         vop_hwc_reg_update(dev_drv, win->id);
1657                 vop_cfg_done(vop_dev);
1658         }
1659
1660         DBG(2, "%s for lcdc%d\n", __func__, vop_dev->id);
1661         return 0;
1662 }
1663
1664 static int __maybe_unused vop_mmu_en(struct rk_lcdc_driver *dev_drv)
1665 {
1666         u64 val;
1667         struct vop_device *vop_dev =
1668             container_of(dev_drv, struct vop_device, driver);
1669
1670         if (unlikely(!vop_dev->clk_on)) {
1671                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
1672                 return 0;
1673         }
1674         if (dev_drv->iommu_enabled) {
1675                 if (!vop_dev->iommu_status && dev_drv->mmu_dev) {
1676                         if (likely(vop_dev->clk_on)) {
1677                                 val = V_VOP_MMU_EN(1);
1678                                 vop_msk_reg(vop_dev, SYS_CTRL, val);
1679                                 val = V_AXI_OUTSTANDING_MAX_NUM(31) |
1680                                         V_AXI_MAX_OUTSTANDING_EN(1);
1681                                 vop_msk_reg(vop_dev, SYS_CTRL1, val);
1682                         }
1683                         vop_dev->iommu_status = 1;
1684                         rockchip_iovmm_activate(dev_drv->dev);
1685                 }
1686         }
1687         return 0;
1688 }
1689
1690 static int vop_set_dclk(struct rk_lcdc_driver *dev_drv, int reset_rate)
1691 {
1692         int ret = 0, fps = 0;
1693         struct vop_device *vop_dev =
1694             container_of(dev_drv, struct vop_device, driver);
1695         struct rk_screen *screen = dev_drv->cur_screen;
1696 #ifdef CONFIG_RK_FPGA
1697         return 0;
1698 #endif
1699         if (reset_rate)
1700                 ret = clk_set_rate(vop_dev->dclk, screen->mode.pixclock);
1701         if (ret)
1702                 dev_err(dev_drv->dev, "set lcdc%d dclk[%d] failed\n",
1703                         vop_dev->id, screen->mode.pixclock);
1704         vop_dev->pixclock =
1705             div_u64(1000000000000llu, clk_get_rate(vop_dev->dclk));
1706         vop_dev->driver.pixclock = vop_dev->pixclock;
1707
1708         fps = rk_fb_calc_fps(screen, vop_dev->pixclock);
1709         screen->ft = 1000 / fps;
1710         dev_info(vop_dev->dev, "%s: dclk:%lu>>fps:%d ",
1711                  vop_dev->driver.name, clk_get_rate(vop_dev->dclk), fps);
1712         return 0;
1713 }
1714
1715 static int vop_config_timing(struct rk_lcdc_driver *dev_drv)
1716 {
1717         struct vop_device *vop_dev =
1718             container_of(dev_drv, struct vop_device, driver);
1719         struct rk_screen *screen = dev_drv->cur_screen;
1720         u16 hsync_len = screen->mode.hsync_len;
1721         u16 left_margin = screen->mode.left_margin;
1722         u16 right_margin = screen->mode.right_margin;
1723         u16 vsync_len = screen->mode.vsync_len;
1724         u16 upper_margin = screen->mode.upper_margin;
1725         u16 lower_margin = screen->mode.lower_margin;
1726         u16 x_res = screen->mode.xres;
1727         u16 y_res = screen->mode.yres;
1728         u64 val;
1729         u16 h_total, v_total;
1730         u16 vact_end_f1, vact_st_f1, vs_end_f1, vs_st_f1;
1731
1732         h_total = hsync_len + left_margin + x_res + right_margin;
1733         v_total = vsync_len + upper_margin + y_res + lower_margin;
1734
1735         val = V_DSP_HS_END(hsync_len) | V_DSP_HTOTAL(h_total);
1736         vop_msk_reg(vop_dev, DSP_HTOTAL_HS_END, val);
1737
1738         val = V_DSP_HACT_END(hsync_len + left_margin + x_res) |
1739             V_DSP_HACT_ST(hsync_len + left_margin);
1740         vop_msk_reg(vop_dev, DSP_HACT_ST_END, val);
1741
1742         if (screen->mode.vmode & FB_VMODE_INTERLACED) {
1743                 /* First Field Timing */
1744                 val = V_DSP_VS_END(vsync_len) |
1745                     V_DSP_VTOTAL(2 * (vsync_len + upper_margin +
1746                                       lower_margin) + y_res + 1);
1747                 vop_msk_reg(vop_dev, DSP_VTOTAL_VS_END, val);
1748
1749                 val = V_DSP_VACT_END(vsync_len + upper_margin + y_res / 2) |
1750                     V_DSP_VACT_ST(vsync_len + upper_margin);
1751                 vop_msk_reg(vop_dev, DSP_VACT_ST_END, val);
1752
1753                 /* Second Field Timing */
1754                 vs_st_f1 = vsync_len + upper_margin + y_res / 2 + lower_margin;
1755                 vs_end_f1 = 2 * vsync_len + upper_margin + y_res / 2 +
1756                     lower_margin;
1757                 val = V_DSP_VS_ST_F1(vs_st_f1) | V_DSP_VS_END_F1(vs_end_f1);
1758                 vop_msk_reg(vop_dev, DSP_VS_ST_END_F1, val);
1759
1760                 vact_end_f1 = 2 * (vsync_len + upper_margin) + y_res +
1761                     lower_margin + 1;
1762                 vact_st_f1 = 2 * (vsync_len + upper_margin) + y_res / 2 +
1763                     lower_margin + 1;
1764                 val = V_DSP_VACT_END_F1(vact_end_f1) |
1765                         V_DSP_VACT_ST_F1(vact_st_f1);
1766                 vop_msk_reg(vop_dev, DSP_VACT_ST_END_F1, val);
1767                 vop_msk_reg(vop_dev, DSP_CTRL0,
1768                             V_DSP_INTERLACE(1) | V_DSP_FIELD_POL(0));
1769
1770                 val = V_DSP_LINE_FLAG_NUM_0(lower_margin ?
1771                                             vact_end_f1 : vact_end_f1 - 1);
1772
1773                 val |= V_DSP_LINE_FLAG_NUM_1(lower_margin ?
1774                                              vact_end_f1 : vact_end_f1 - 1);
1775                 vop_msk_reg(vop_dev, LINE_FLAG, val);
1776         } else {
1777                 val = V_DSP_VS_END(vsync_len) | V_DSP_VTOTAL(v_total);
1778                 vop_msk_reg(vop_dev, DSP_VTOTAL_VS_END, val);
1779
1780                 val = V_DSP_VACT_END(vsync_len + upper_margin + y_res) |
1781                     V_DSP_VACT_ST(vsync_len + upper_margin);
1782                 vop_msk_reg(vop_dev, DSP_VACT_ST_END, val);
1783
1784                 vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_INTERLACE(0) |
1785                             V_DSP_FIELD_POL(0));
1786
1787                 val = V_DSP_LINE_FLAG_NUM_0(vsync_len + upper_margin + y_res) |
1788                         V_DSP_LINE_FLAG_NUM_1(vsync_len + upper_margin + y_res);
1789                 vop_msk_reg(vop_dev, LINE_FLAG, val);
1790         }
1791         vop_post_cfg(dev_drv);
1792         if ((x_res <= VOP_INPUT_MAX_WIDTH / 2) && (vop_dev->id == 0))
1793                 vop_msk_reg(vop_dev, SYS_CTRL, V_POST_LB_MODE(1));
1794         else
1795                 vop_msk_reg(vop_dev, SYS_CTRL, V_POST_LB_MODE(0));
1796
1797         return 0;
1798 }
1799
1800 static void vop_bcsh_path_sel(struct rk_lcdc_driver *dev_drv)
1801 {
1802         struct vop_device *vop_dev =
1803             container_of(dev_drv, struct vop_device, driver);
1804         u32 bcsh_ctrl;
1805
1806         vop_msk_reg(vop_dev, SYS_CTRL, V_OVERLAY_MODE(dev_drv->overlay_mode));
1807         if (dev_drv->overlay_mode == VOP_YUV_DOMAIN) {
1808                 if (dev_drv->output_color == COLOR_YCBCR)       /* bypass */
1809                         vop_msk_reg(vop_dev, BCSH_CTRL,
1810                                     V_BCSH_Y2R_EN(0) | V_BCSH_R2Y_EN(0));
1811                 else            /* YUV2RGB */
1812                         vop_msk_reg(vop_dev, BCSH_CTRL, V_BCSH_Y2R_EN(1) |
1813                                     V_BCSH_Y2R_CSC_MODE(VOP_Y2R_CSC_MPEG) |
1814                                     V_BCSH_R2Y_EN(0));
1815         } else {
1816                 /* overlay_mode=VOP_RGB_DOMAIN */
1817                 /* bypass  --need check,if bcsh close? */
1818                 if (dev_drv->output_color == COLOR_RGB) {
1819                         bcsh_ctrl = vop_readl(vop_dev, BCSH_CTRL);
1820                         if (((bcsh_ctrl & MASK(BCSH_EN)) == 1) ||
1821                             (dev_drv->bcsh.enable == 1))/*bcsh enabled */
1822                                 vop_msk_reg(vop_dev, BCSH_CTRL,
1823                                             V_BCSH_R2Y_EN(1) |
1824                                             V_BCSH_Y2R_EN(1));
1825                         else
1826                                 vop_msk_reg(vop_dev, BCSH_CTRL,
1827                                             V_BCSH_R2Y_EN(0) |
1828                                             V_BCSH_Y2R_EN(0));
1829                 } else {
1830                         /* RGB2YUV */
1831                         vop_msk_reg(vop_dev, BCSH_CTRL,
1832                                     V_BCSH_R2Y_EN(1) |
1833                                     V_BCSH_R2Y_CSC_MODE(VOP_Y2R_CSC_MPEG) |
1834                                     V_BCSH_Y2R_EN(0));
1835                 }
1836         }
1837 }
1838
1839 static int vop_get_dspbuf_info(struct rk_lcdc_driver *dev_drv, u16 *xact,
1840                                u16 *yact, int *format, u32 *dsp_addr,
1841                                int *ymirror)
1842 {
1843         struct vop_device *vop_dev =
1844                         container_of(dev_drv, struct vop_device, driver);
1845         u32 val;
1846
1847         spin_lock(&vop_dev->reg_lock);
1848
1849         val = vop_readl(vop_dev, WIN0_ACT_INFO);
1850         *xact = (val & MASK(WIN0_ACT_WIDTH)) + 1;
1851         *yact = ((val & MASK(WIN0_ACT_HEIGHT)) >> 16) + 1;
1852
1853         val = vop_readl(vop_dev, WIN0_CTRL0);
1854         *format = (val & MASK(WIN0_DATA_FMT)) >> 1;
1855         *ymirror = (val & MASK(WIN0_Y_MIR_EN)) >> 22;
1856         *dsp_addr = vop_readl(vop_dev, WIN0_YRGB_MST);
1857
1858         spin_unlock(&vop_dev->reg_lock);
1859
1860         return 0;
1861 }
1862
1863 static int vop_post_dspbuf(struct rk_lcdc_driver *dev_drv, u32 rgb_mst,
1864                            int format, u16 xact, u16 yact, u16 xvir,
1865                            int ymirror)
1866 {
1867         struct vop_device *vop_dev =
1868                         container_of(dev_drv, struct vop_device, driver);
1869         int swap = (format == RGB888) ? 1 : 0;
1870         struct rk_lcdc_win *win = dev_drv->win[0];
1871         u64 val;
1872
1873         val = V_WIN0_DATA_FMT(format) | V_WIN0_RB_SWAP(swap) |
1874                 V_WIN0_Y_MIR_EN(ymirror);
1875         vop_msk_reg(vop_dev, WIN0_CTRL0, val);
1876
1877         vop_msk_reg(vop_dev, WIN0_VIR, V_WIN0_VIR_STRIDE(xvir));
1878         vop_writel(vop_dev, WIN0_ACT_INFO, V_WIN0_ACT_WIDTH(xact - 1) |
1879                    V_WIN0_ACT_HEIGHT(yact - 1));
1880
1881         vop_writel(vop_dev, WIN0_YRGB_MST, rgb_mst);
1882
1883         vop_cfg_done(vop_dev);
1884
1885         if (format == RGB888)
1886                 win->area[0].format = BGR888;
1887         else
1888                 win->area[0].format = format;
1889
1890         win->ymirror = ymirror;
1891         win->state = 1;
1892         win->last_state = 1;
1893
1894         return 0;
1895 }
1896
1897 static int vop_load_screen(struct rk_lcdc_driver *dev_drv, bool initscreen)
1898 {
1899         u16 face = 0;
1900         u16 dclk_ddr = 0;
1901         struct vop_device *vop_dev =
1902             container_of(dev_drv, struct vop_device, driver);
1903         struct rk_screen *screen = dev_drv->cur_screen;
1904         u64 val = 0;
1905
1906         if (unlikely(!vop_dev->clk_on)) {
1907                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
1908                 return 0;
1909         }
1910
1911         if (!vop_dev->standby && initscreen && (dev_drv->first_frame != 1))
1912                 flush_kthread_worker(&dev_drv->update_regs_worker);
1913
1914         spin_lock(&vop_dev->reg_lock);
1915         if (likely(vop_dev->clk_on)) {
1916                 switch (screen->face) {
1917                 case OUT_P565:
1918                         face = OUT_P565;
1919                         val = V_DITHER_DOWN_EN(1) | V_DITHER_UP_EN(1) |
1920                                 V_PRE_DITHER_DOWN_EN(1) |
1921                                 V_DITHER_DOWN_SEL(1) | V_DITHER_DOWN_MODE(0);
1922                         break;
1923                 case OUT_P666:
1924                         face = OUT_P666;
1925                         val = V_DITHER_DOWN_EN(1) | V_DITHER_UP_EN(1) |
1926                                 V_PRE_DITHER_DOWN_EN(1) |
1927                                 V_DITHER_DOWN_SEL(1) | V_DITHER_DOWN_MODE(1);
1928                         break;
1929                 case OUT_D888_P565:
1930                         face = OUT_P888;
1931                         val = V_DITHER_DOWN_EN(1) | V_DITHER_UP_EN(1) |
1932                                 V_PRE_DITHER_DOWN_EN(1) |
1933                                 V_DITHER_DOWN_SEL(1) | V_DITHER_DOWN_MODE(0);
1934                         break;
1935                 case OUT_D888_P666:
1936                         face = OUT_P888;
1937                         val = V_DITHER_DOWN_EN(1) | V_DITHER_UP_EN(1) |
1938                                 V_PRE_DITHER_DOWN_EN(1) |
1939                                 V_DITHER_DOWN_SEL(1) | V_DITHER_DOWN_MODE(1);
1940                         break;
1941                 case OUT_P888:
1942                         face = OUT_P888;
1943                         val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1)
1944                                 | V_PRE_DITHER_DOWN_EN(1) |
1945                                 V_DITHER_DOWN_SEL(0) | V_DITHER_DOWN_MODE(0);
1946                         break;
1947                 case OUT_YUV_420:
1948                         face = OUT_YUV_420;
1949                         dclk_ddr = 1;
1950                         val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1) |
1951                                 V_PRE_DITHER_DOWN_EN(1) |
1952                                 V_DITHER_DOWN_SEL(0) |
1953                                 V_DITHER_DOWN_MODE(0);
1954                         break;
1955                 case OUT_YUV_420_10BIT:
1956                         face = OUT_YUV_420;
1957                         dclk_ddr = 1;
1958                         val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1) |
1959                                 V_PRE_DITHER_DOWN_EN(0) |
1960                                 V_DITHER_DOWN_SEL(0) |
1961                                 V_DITHER_DOWN_MODE(0);
1962                         break;
1963                 case OUT_P101010:
1964                         face = OUT_P101010;
1965                         val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1) |
1966                                 V_PRE_DITHER_DOWN_EN(0) |
1967                                 V_DITHER_DOWN_SEL(0) |
1968                                 V_DITHER_DOWN_MODE(0);
1969                         break;
1970                 default:
1971                         dev_err(vop_dev->dev, "un supported screen face[%d]!\n",
1972                                 screen->face);
1973                         break;
1974                 }
1975
1976                 vop_msk_reg(vop_dev, DSP_CTRL1, val);
1977                 switch (screen->type) {
1978                 case SCREEN_TVOUT:
1979                         val = V_SW_UV_OFFSET_EN(1) | V_SW_IMD_TVE_DCLK_EN(1) |
1980                                 V_SW_IMD_TVE_DCLK_EN(1) |
1981                                 V_SW_IMD_TVE_DCLK_POL(1) |
1982                                 V_SW_GENLOCK(1) | V_SW_DAC_SEL(1);
1983                         if (screen->mode.xres == 720 &&
1984                             screen->mode.yres == 576)
1985                                 val |= V_SW_TVE_MODE(1);
1986                         else
1987                                 val |= V_SW_TVE_MODE(0);
1988                         vop_msk_reg(vop_dev, SYS_CTRL, val);
1989                         break;
1990                 case SCREEN_HDMI:
1991                         if ((VOP_CHIP(vop_dev) == VOP_RK3399) &&
1992                             ((screen->face == OUT_P888) ||
1993                              (screen->face == OUT_P101010))) {
1994                                 if (vop_dev->id == 0)
1995                                         face = OUT_P101010; /*RGB 10bit output*/
1996                                 else
1997                                         face = OUT_P888;
1998                         }
1999                         val = V_HDMI_OUT_EN(1) | V_SW_UV_OFFSET_EN(0);
2000                         vop_msk_reg(vop_dev, SYS_CTRL, val);
2001                         val = V_HDMI_HSYNC_POL(screen->pin_hsync) |
2002                                 V_HDMI_VSYNC_POL(screen->pin_vsync) |
2003                                 V_HDMI_DEN_POL(screen->pin_den) |
2004                                 V_HDMI_DCLK_POL(screen->pin_dclk);
2005                         /*hsync vsync den dclk polo,dither */
2006                         vop_msk_reg(vop_dev, DSP_CTRL1, val);
2007                         break;
2008                 case SCREEN_RGB:
2009                 case SCREEN_LVDS:
2010                         val = V_RGB_OUT_EN(1);
2011                         vop_msk_reg(vop_dev, SYS_CTRL, val);
2012                         break;
2013                 case SCREEN_MIPI:
2014                         val = V_MIPI_OUT_EN(1);
2015                         vop_msk_reg(vop_dev, SYS_CTRL, val);
2016                         val = V_MIPI_HSYNC_POL(screen->pin_hsync) |
2017                                 V_MIPI_VSYNC_POL(screen->pin_vsync) |
2018                                 V_MIPI_DEN_POL(screen->pin_den) |
2019                                 V_MIPI_DCLK_POL(screen->pin_dclk);
2020                         /*hsync vsync den dclk polo,dither */
2021                         vop_msk_reg(vop_dev, DSP_CTRL1, val);
2022                         break;
2023                 case SCREEN_DUAL_MIPI:
2024                         val = V_MIPI_OUT_EN(1) | V_MIPI_DUAL_CHANNEL_EN(1);
2025                         vop_msk_reg(vop_dev, SYS_CTRL, val);
2026                         val = V_MIPI_HSYNC_POL(screen->pin_hsync) |
2027                                 V_MIPI_VSYNC_POL(screen->pin_vsync) |
2028                                 V_MIPI_DEN_POL(screen->pin_den) |
2029                                 V_MIPI_DCLK_POL(screen->pin_dclk);
2030                         /*hsync vsync den dclk polo,dither */
2031                         vop_msk_reg(vop_dev, DSP_CTRL1, val);
2032                         break;
2033                 case SCREEN_EDP:
2034                         if ((VOP_CHIP(vop_dev) == VOP_RK3399) &&
2035                             (vop_dev->id == 0))
2036                                 face = OUT_P101010;
2037                         val = V_EDP_OUT_EN(1);
2038                         vop_msk_reg(vop_dev, SYS_CTRL, val);
2039                         val = V_EDP_HSYNC_POL(screen->pin_hsync) |
2040                                 V_EDP_VSYNC_POL(screen->pin_vsync) |
2041                                 V_EDP_DEN_POL(screen->pin_den) |
2042                                 V_EDP_DCLK_POL(screen->pin_dclk);
2043                         /*hsync vsync den dclk polo,dither */
2044                         vop_msk_reg(vop_dev, DSP_CTRL1, val);
2045                         break;
2046                 default:
2047                         dev_err(vop_dev->dev, "un supported interface[%d]!\n",
2048                                 screen->type);
2049                         break;
2050                 }
2051
2052                 if (screen->color_mode == COLOR_RGB)
2053                         dev_drv->overlay_mode = VOP_RGB_DOMAIN;
2054                 else
2055                         dev_drv->overlay_mode = VOP_YUV_DOMAIN;
2056
2057 #ifndef CONFIG_RK_FPGA
2058                 /*
2059                  * Todo:
2060                  * writel_relaxed(v, RK_GRF_VIRT + vop_GRF_SOC_CON7);
2061                  *  move to  lvds driver
2062                  */
2063                 /*GRF_SOC_CON7 bit[15]:0->dsi/lvds mode,1->ttl mode */
2064 #endif
2065                 val = V_DSP_OUT_MODE(face) | V_DSP_DCLK_DDR(dclk_ddr) |
2066                     V_DSP_BG_SWAP(screen->swap_gb) |
2067                     V_DSP_RB_SWAP(screen->swap_rb) |
2068                     V_DSP_RG_SWAP(screen->swap_rg) |
2069                     V_DSP_DELTA_SWAP(screen->swap_delta) |
2070                     V_DSP_DUMMY_SWAP(screen->swap_dumy) | V_DSP_OUT_ZERO(0) |
2071                     V_DSP_BLANK_EN(0) | V_DSP_BLACK_EN(0) |
2072                     V_DSP_X_MIR_EN(screen->x_mirror) |
2073                     V_DSP_Y_MIR_EN(screen->y_mirror);
2074                 val |= V_SW_CORE_DCLK_SEL(!!screen->pixelrepeat);
2075                 if (screen->mode.vmode & FB_VMODE_INTERLACED)
2076                         val |= V_SW_HDMI_CLK_I_SEL(1);
2077                 else
2078                         val |= V_SW_HDMI_CLK_I_SEL(0);
2079                 vop_msk_reg(vop_dev, DSP_CTRL0, val);
2080
2081                 if (screen->mode.vmode & FB_VMODE_INTERLACED)
2082                         vop_msk_reg(vop_dev, SYS_CTRL1, V_REG_DONE_FRM(1));
2083                 else
2084                         vop_msk_reg(vop_dev, SYS_CTRL1, V_REG_DONE_FRM(0));
2085                 /* BG color */
2086                 if (dev_drv->overlay_mode == VOP_YUV_DOMAIN) {
2087                         val = V_DSP_OUT_RGB_YUV(1);
2088                         vop_msk_reg(vop_dev, POST_SCL_CTRL, val);
2089                         val = V_DSP_BG_BLUE(0x200) | V_DSP_BG_GREEN(0x40) |
2090                                 V_DSP_BG_RED(0x200);
2091                         vop_msk_reg(vop_dev, DSP_BG, val);
2092                 } else {
2093                         val = V_DSP_OUT_RGB_YUV(0);
2094                         vop_msk_reg(vop_dev, POST_SCL_CTRL, val);
2095                         val = V_DSP_BG_BLUE(0x55) | V_DSP_BG_GREEN(0x55) |
2096                                 V_DSP_BG_RED(0x55);
2097                         vop_msk_reg(vop_dev, DSP_BG, val);
2098                 }
2099                 dev_drv->output_color = screen->color_mode;
2100                 vop_bcsh_path_sel(dev_drv);
2101                 vop_config_timing(dev_drv);
2102                 vop_cfg_done(vop_dev);
2103         }
2104         spin_unlock(&vop_dev->reg_lock);
2105         vop_set_dclk(dev_drv, 1);
2106         if (screen->type != SCREEN_HDMI && screen->type != SCREEN_TVOUT &&
2107             dev_drv->trsm_ops && dev_drv->trsm_ops->enable)
2108                 dev_drv->trsm_ops->enable();
2109         if (screen->init)
2110                 screen->init();
2111
2112         return 0;
2113 }
2114
2115 static int vop_early_suspend(struct rk_lcdc_driver *dev_drv);
2116 static int vop_early_resume(struct rk_lcdc_driver *dev_drv);
2117 /*enable layer,open:1,enable;0 disable*/
2118 static void vop_layer_enable(struct vop_device *vop_dev,
2119                              unsigned int win_id, bool open)
2120 {
2121         spin_lock(&vop_dev->reg_lock);
2122         if (likely(vop_dev->clk_on) &&
2123             vop_dev->driver.win[win_id]->state != open) {
2124                 if (open) {
2125                         if (!vop_dev->atv_layer_cnt) {
2126                                 dev_info(vop_dev->dev,
2127                                          "wakeup from standby!\n");
2128                                 vop_dev->standby = 0;
2129                         }
2130                         vop_dev->atv_layer_cnt |= (1 << win_id);
2131                 } else {
2132                         if (vop_dev->atv_layer_cnt & (1 << win_id))
2133                                 vop_dev->atv_layer_cnt &= ~(1 << win_id);
2134                 }
2135                 vop_dev->driver.win[win_id]->state = open;
2136                 if (!open) {
2137                         vop_layer_update_regs(vop_dev,
2138                                               vop_dev->driver.win[win_id]);
2139                         vop_cfg_done(vop_dev);
2140                 }
2141         }
2142         spin_unlock(&vop_dev->reg_lock);
2143         /* if no layer used,disable lcdc */
2144         if (vop_dev->prop == EXTEND) {
2145                 if (!vop_dev->atv_layer_cnt && !open) {
2146                         vop_early_suspend(&vop_dev->driver);
2147                         dev_info(vop_dev->dev,
2148                                  "no layer is used,go to standby!\n");
2149                         vop_dev->standby = 1;
2150                 } else if (open) {
2151                         vop_early_resume(&vop_dev->driver);
2152                         dev_info(vop_dev->dev, "wake up from standby!\n");
2153                 }
2154         }
2155
2156 }
2157
2158 static int vop_enable_irq(struct rk_lcdc_driver *dev_drv)
2159 {
2160         struct vop_device *vop_dev = container_of(dev_drv,
2161                                                     struct vop_device, driver);
2162         u64 val;
2163         /* struct rk_screen *screen = dev_drv->cur_screen; */
2164
2165         vop_mask_writel(vop_dev, INTR_CLEAR0, INTR_MASK, INTR_MASK);
2166
2167         val = INTR_FS | INTR_LINE_FLAG0 | INTR_BUS_ERROR | INTR_LINE_FLAG1 |
2168                 INTR_WIN0_EMPTY | INTR_WIN1_EMPTY | INTR_HWC_EMPTY |
2169                 INTR_POST_BUF_EMPTY;
2170         val |= val << 16;
2171
2172         vop_msk_reg(vop_dev, INTR_EN0, val);
2173
2174         return 0;
2175 }
2176
2177 static int vop_open(struct rk_lcdc_driver *dev_drv, int win_id,
2178                     bool open)
2179 {
2180         struct vop_device *vop_dev =
2181             container_of(dev_drv, struct vop_device, driver);
2182
2183         /* enable clk,when first layer open */
2184         if ((open) && (!vop_dev->atv_layer_cnt)) {
2185                 /* rockchip_set_system_status(sys_status); */
2186                 vop_pre_init(dev_drv);
2187                 vop_clk_enable(vop_dev);
2188                 vop_enable_irq(dev_drv);
2189                 if (dev_drv->iommu_enabled) {
2190                         if (!dev_drv->mmu_dev) {
2191                                 dev_drv->mmu_dev =
2192                                     rk_fb_get_sysmmu_device_by_compatible
2193                                     (dev_drv->mmu_dts_name);
2194                                 if (dev_drv->mmu_dev) {
2195                                         rk_fb_platform_set_sysmmu
2196                                             (dev_drv->mmu_dev, dev_drv->dev);
2197                                 } else {
2198                                         dev_err(dev_drv->dev,
2199                                                 "fail get rk iommu device\n");
2200                                         return -1;
2201                                 }
2202                         }
2203                 }
2204                 if ((support_uboot_display() && (vop_dev->prop == PRMRY)))
2205                         vop_set_dclk(dev_drv, 0);
2206                 else
2207                         vop_load_screen(dev_drv, 1);
2208                 if (dev_drv->bcsh.enable)
2209                         vop_set_bcsh(dev_drv, 1);
2210                 vop_set_lut(dev_drv, dev_drv->cur_screen->dsp_lut);
2211                 vop_set_cabc(dev_drv, dev_drv->cur_screen->cabc_lut);
2212         }
2213
2214         if (win_id < dev_drv->lcdc_win_num)
2215                 vop_layer_enable(vop_dev, win_id, open);
2216         else
2217                 dev_err(vop_dev->dev, "invalid win id:%d\n", win_id);
2218
2219         dev_drv->first_frame = 0;
2220         return 0;
2221 }
2222
2223 static int win_0_1_display(struct vop_device *vop_dev,
2224                            struct rk_lcdc_win *win)
2225 {
2226         u32 y_addr;
2227         u32 uv_addr;
2228         unsigned int off;
2229
2230         off = win->id * 0x40;
2231         /*win->smem_start + win->y_offset; */
2232         y_addr = win->area[0].smem_start + win->area[0].y_offset;
2233         uv_addr = win->area[0].cbr_start + win->area[0].c_offset;
2234         DBG(2, "lcdc[%d]:win[%d]>>:y_addr:0x%x>>uv_addr:0x%x",
2235             vop_dev->id, win->id, y_addr, uv_addr);
2236         DBG(2, ">>y_offset:0x%x>>c_offset=0x%x\n",
2237             win->area[0].y_offset, win->area[0].c_offset);
2238         spin_lock(&vop_dev->reg_lock);
2239         if (likely(vop_dev->clk_on)) {
2240                 win->area[0].y_addr = y_addr;
2241                 win->area[0].uv_addr = uv_addr;
2242                 vop_writel(vop_dev, WIN0_YRGB_MST + off, win->area[0].y_addr);
2243                 vop_writel(vop_dev, WIN0_CBR_MST + off, win->area[0].uv_addr);
2244                 if (win->area[0].fbdc_en == 1)
2245                         vop_writel(vop_dev, AFBCD0_HDR_PTR,
2246                                    win->area[0].y_addr);
2247         }
2248         spin_unlock(&vop_dev->reg_lock);
2249
2250         return 0;
2251 }
2252
2253 static int win_2_3_display(struct vop_device *vop_dev,
2254                            struct rk_lcdc_win *win)
2255 {
2256         u32 i, y_addr;
2257         unsigned int off;
2258
2259         off = (win->id - 2) * 0x50;
2260         y_addr = win->area[0].smem_start + win->area[0].y_offset;
2261         DBG(2, "lcdc[%d]:win[%d]:", vop_dev->id, win->id);
2262
2263         if (likely(vop_dev->clk_on)) {
2264                 for (i = 0; i < win->area_num; i++) {
2265                         DBG(2, "area[%d]:yaddr:0x%x>>offset:0x%x>>\n",
2266                             i, win->area[i].y_addr, win->area[i].y_offset);
2267                         win->area[i].y_addr =
2268                             win->area[i].smem_start + win->area[i].y_offset;
2269                         }
2270                 spin_lock(&vop_dev->reg_lock);
2271                 vop_writel(vop_dev, WIN2_MST0 + off, win->area[0].y_addr);
2272                 vop_writel(vop_dev, WIN2_MST1 + off, win->area[1].y_addr);
2273                 vop_writel(vop_dev, WIN2_MST2 + off, win->area[2].y_addr);
2274                 vop_writel(vop_dev, WIN2_MST3 + off, win->area[3].y_addr);
2275                 if (win->area[0].fbdc_en == 1)
2276                         vop_writel(vop_dev, AFBCD0_HDR_PTR,
2277                                    win->area[0].y_addr);
2278                 spin_unlock(&vop_dev->reg_lock);
2279         }
2280         return 0;
2281 }
2282
2283 static int hwc_display(struct vop_device *vop_dev, struct rk_lcdc_win *win)
2284 {
2285         u32 y_addr;
2286
2287         y_addr = win->area[0].smem_start + win->area[0].y_offset;
2288         DBG(2, "lcdc[%d]:hwc>>%s>>y_addr:0x%x>>\n",
2289             vop_dev->id, __func__, y_addr);
2290         spin_lock(&vop_dev->reg_lock);
2291         if (likely(vop_dev->clk_on)) {
2292                 win->area[0].y_addr = y_addr;
2293                 vop_writel(vop_dev, HWC_MST, win->area[0].y_addr);
2294         }
2295         spin_unlock(&vop_dev->reg_lock);
2296
2297         return 0;
2298 }
2299
2300 static int vop_pan_display(struct rk_lcdc_driver *dev_drv, int win_id)
2301 {
2302         struct vop_device *vop_dev =
2303             container_of(dev_drv, struct vop_device, driver);
2304         struct rk_lcdc_win *win = NULL;
2305         struct rk_screen *screen = dev_drv->cur_screen;
2306
2307         win = dev_drv->win[win_id];
2308         if (!screen) {
2309                 dev_err(dev_drv->dev, "screen is null!\n");
2310                 return -ENOENT;
2311         }
2312         if (unlikely(!vop_dev->clk_on)) {
2313                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
2314                 return 0;
2315         }
2316         if (win_id == 0) {
2317                 win_0_1_display(vop_dev, win);
2318         } else if (win_id == 1) {
2319                 win_0_1_display(vop_dev, win);
2320         } else if (win_id == 2) {
2321                 win_2_3_display(vop_dev, win);
2322         } else if (win_id == 3) {
2323                 win_2_3_display(vop_dev, win);
2324         } else if (win_id == 4) {
2325                 hwc_display(vop_dev, win);
2326         } else {
2327                 dev_err(dev_drv->dev, "invalid win number:%d!\n", win_id);
2328                 return -EINVAL;
2329         }
2330
2331         return 0;
2332 }
2333
2334 static int vop_cal_scl_fac(struct rk_lcdc_win *win, struct rk_screen *screen)
2335 {
2336         u16 srcW = 0;
2337         u16 srcH = 0;
2338         u16 dstW = 0;
2339         u16 dstH = 0;
2340         u16 yrgb_srcW = 0;
2341         u16 yrgb_srcH = 0;
2342         u16 yrgb_dstW = 0;
2343         u16 yrgb_dstH = 0;
2344         u32 yrgb_vscalednmult = 0;
2345         u32 yrgb_xscl_factor = 0;
2346         u32 yrgb_yscl_factor = 0;
2347         u8 yrgb_vsd_bil_gt2 = 0;
2348         u8 yrgb_vsd_bil_gt4 = 0;
2349
2350         u16 cbcr_srcW = 0;
2351         u16 cbcr_srcH = 0;
2352         u16 cbcr_dstW = 0;
2353         u16 cbcr_dstH = 0;
2354         u32 cbcr_vscalednmult = 0;
2355         u32 cbcr_xscl_factor = 0;
2356         u32 cbcr_yscl_factor = 0;
2357         u8 cbcr_vsd_bil_gt2 = 0;
2358         u8 cbcr_vsd_bil_gt4 = 0;
2359         u8 yuv_fmt = 0;
2360
2361         srcW = win->area[0].xact;
2362         if ((screen->mode.vmode & FB_VMODE_INTERLACED) &&
2363             (win->area[0].yact == 2 * win->area[0].ysize)) {
2364                 srcH = win->area[0].yact / 2;
2365                 yrgb_vsd_bil_gt2 = 1;
2366                 cbcr_vsd_bil_gt2 = 1;
2367         } else {
2368                 srcH = win->area[0].yact;
2369         }
2370         dstW = win->area[0].xsize;
2371         dstH = win->area[0].ysize;
2372
2373         /*yrgb scl mode */
2374         yrgb_srcW = srcW;
2375         yrgb_srcH = srcH;
2376         yrgb_dstW = dstW;
2377         yrgb_dstH = dstH;
2378         if ((yrgb_dstW * 8 <= yrgb_srcW) || (yrgb_dstH * 8 <= yrgb_srcH)) {
2379                 pr_err("ERROR: yrgb scale exceed 8,");
2380                 pr_err("srcW=%d,srcH=%d,dstW=%d,dstH=%d\n",
2381                        yrgb_srcW, yrgb_srcH, yrgb_dstW, yrgb_dstH);
2382         }
2383         if (yrgb_srcW < yrgb_dstW)
2384                 win->yrgb_hor_scl_mode = SCALE_UP;
2385         else if (yrgb_srcW > yrgb_dstW)
2386                 win->yrgb_hor_scl_mode = SCALE_DOWN;
2387         else
2388                 win->yrgb_hor_scl_mode = SCALE_NONE;
2389
2390         if (yrgb_srcH < yrgb_dstH)
2391                 win->yrgb_ver_scl_mode = SCALE_UP;
2392         else if (yrgb_srcH > yrgb_dstH)
2393                 win->yrgb_ver_scl_mode = SCALE_DOWN;
2394         else
2395                 win->yrgb_ver_scl_mode = SCALE_NONE;
2396
2397         /*cbcr scl mode */
2398         switch (win->area[0].format) {
2399         case YUV422:
2400         case YUYV422:
2401         case UYVY422:
2402         case YUV422_A:
2403                 cbcr_srcW = srcW / 2;
2404                 cbcr_dstW = dstW;
2405                 cbcr_srcH = srcH;
2406                 cbcr_dstH = dstH;
2407                 yuv_fmt = 1;
2408                 break;
2409         case YUV420:
2410         case YUYV420:
2411         case UYVY420:
2412         case YUV420_A:
2413         case YUV420_NV21:
2414                 cbcr_srcW = srcW / 2;
2415                 cbcr_dstW = dstW;
2416                 cbcr_srcH = srcH / 2;
2417                 cbcr_dstH = dstH;
2418                 yuv_fmt = 1;
2419                 break;
2420         case YUV444:
2421         case YUV444_A:
2422                 cbcr_srcW = srcW;
2423                 cbcr_dstW = dstW;
2424                 cbcr_srcH = srcH;
2425                 cbcr_dstH = dstH;
2426                 yuv_fmt = 1;
2427                 break;
2428         default:
2429                 cbcr_srcW = 0;
2430                 cbcr_dstW = 0;
2431                 cbcr_srcH = 0;
2432                 cbcr_dstH = 0;
2433                 yuv_fmt = 0;
2434                 break;
2435         }
2436         if (yuv_fmt) {
2437                 if ((cbcr_dstW * 8 <= cbcr_srcW) ||
2438                     (cbcr_dstH * 8 <= cbcr_srcH)) {
2439                         pr_err("ERROR: cbcr scale exceed 8,");
2440                         pr_err("srcW=%d,srcH=%d,dstW=%d,dstH=%d\n", cbcr_srcW,
2441                                cbcr_srcH, cbcr_dstW, cbcr_dstH);
2442                 }
2443         }
2444
2445         if (cbcr_srcW < cbcr_dstW)
2446                 win->cbr_hor_scl_mode = SCALE_UP;
2447         else if (cbcr_srcW > cbcr_dstW)
2448                 win->cbr_hor_scl_mode = SCALE_DOWN;
2449         else
2450                 win->cbr_hor_scl_mode = SCALE_NONE;
2451
2452         if (cbcr_srcH < cbcr_dstH)
2453                 win->cbr_ver_scl_mode = SCALE_UP;
2454         else if (cbcr_srcH > cbcr_dstH)
2455                 win->cbr_ver_scl_mode = SCALE_DOWN;
2456         else
2457                 win->cbr_ver_scl_mode = SCALE_NONE;
2458
2459         /* line buffer mode */
2460         if ((win->area[0].format == YUV422) ||
2461             (win->area[0].format == YUV420) ||
2462             (win->area[0].format == YUYV422) ||
2463             (win->area[0].format == YUYV420) ||
2464             (win->area[0].format == UYVY422) ||
2465             (win->area[0].format == UYVY420) ||
2466             (win->area[0].format == YUV420_NV21) ||
2467             (win->area[0].format == YUV422_A) ||
2468             (win->area[0].format == YUV420_A)) {
2469                 if (win->cbr_hor_scl_mode == SCALE_DOWN) {
2470                         if ((cbcr_dstW > VOP_INPUT_MAX_WIDTH / 2) ||
2471                             (cbcr_dstW == 0))
2472                                 pr_err("ERROR cbcr_dstW = %d,exceeds 2048\n",
2473                                        cbcr_dstW);
2474                         else if (cbcr_dstW > 1280)
2475                                 win->win_lb_mode = LB_YUV_3840X5;
2476                         else
2477                                 win->win_lb_mode = LB_YUV_2560X8;
2478                 } else {        /* SCALE_UP or SCALE_NONE */
2479                         if ((cbcr_srcW > VOP_INPUT_MAX_WIDTH / 2) ||
2480                             (cbcr_srcW == 0))
2481                                 pr_err("ERROR cbcr_srcW = %d,exceeds 2048\n",
2482                                        cbcr_srcW);
2483                         else if (cbcr_srcW > 1280)
2484                                 win->win_lb_mode = LB_YUV_3840X5;
2485                         else
2486                                 win->win_lb_mode = LB_YUV_2560X8;
2487                 }
2488         } else {
2489                 if (win->yrgb_hor_scl_mode == SCALE_DOWN) {
2490                         if ((yrgb_dstW > VOP_INPUT_MAX_WIDTH) ||
2491                             (yrgb_dstW == 0))
2492                                 pr_err("ERROR yrgb_dstW = %d\n", yrgb_dstW);
2493                         else if (yrgb_dstW > 2560)
2494                                 win->win_lb_mode = LB_RGB_3840X2;
2495                         else if (yrgb_dstW > 1920)
2496                                 win->win_lb_mode = LB_RGB_2560X4;
2497                         else if (yrgb_dstW > 1280)
2498                                 win->win_lb_mode = LB_RGB_1920X5;
2499                         else
2500                                 win->win_lb_mode = LB_RGB_1280X8;
2501                 } else {        /* SCALE_UP or SCALE_NONE */
2502                         if ((yrgb_srcW > VOP_INPUT_MAX_WIDTH) ||
2503                             (yrgb_srcW == 0))
2504                                 pr_err("ERROR yrgb_srcW = %d\n", yrgb_srcW);
2505                         else if (yrgb_srcW > 2560)
2506                                 win->win_lb_mode = LB_RGB_3840X2;
2507                         else if (yrgb_srcW > 1920)
2508                                 win->win_lb_mode = LB_RGB_2560X4;
2509                         else if (yrgb_srcW > 1280)
2510                                 win->win_lb_mode = LB_RGB_1920X5;
2511                         else
2512                                 win->win_lb_mode = LB_RGB_1280X8;
2513                 }
2514         }
2515         DBG(1, "win->win_lb_mode = %d;\n", win->win_lb_mode);
2516
2517         /* vsd/vsu scale ALGORITHM */
2518         win->yrgb_hsd_mode = SCALE_DOWN_BIL;    /*not to specify */
2519         win->cbr_hsd_mode = SCALE_DOWN_BIL;     /*not to specify */
2520         win->yrgb_vsd_mode = SCALE_DOWN_BIL;    /*not to specify */
2521         win->cbr_vsd_mode = SCALE_DOWN_BIL;     /*not to specify */
2522
2523         /* if (VOP_CHIP(vop_dev) == VOP_RK3399) { */
2524         if ((win->area[0].format == YUYV422) ||
2525             (win->area[0].format == YUYV420) ||
2526             (win->area[0].format == UYVY422) ||
2527             (win->area[0].format == UYVY420)) {
2528                 yrgb_vscalednmult =
2529                         vop_get_hard_ware_vskiplines(yrgb_srcH, yrgb_dstH);
2530                 if (yrgb_vscalednmult == 4) {
2531                         yrgb_vsd_bil_gt4 = 1;
2532                         yrgb_vsd_bil_gt2 = 0;
2533                 } else if (yrgb_vscalednmult == 2) {
2534                         yrgb_vsd_bil_gt4 = 0;
2535                         yrgb_vsd_bil_gt2 = 1;
2536                 } else {
2537                         yrgb_vsd_bil_gt4 = 0;
2538                         yrgb_vsd_bil_gt2 = 0;
2539                 }
2540                 if ((win->area[0].format == YUYV420) ||
2541                     (win->area[0].format == UYVY420)) {
2542                         if ((yrgb_vsd_bil_gt4 == 1) || (yrgb_vsd_bil_gt2 == 1))
2543                                 win->yrgb_vsd_mode = SCALE_DOWN_AVG;
2544                 }
2545
2546                 cbcr_vscalednmult =
2547                         vop_get_hard_ware_vskiplines(cbcr_srcH, cbcr_dstH);
2548                 if (cbcr_vscalednmult == 4) {
2549                         cbcr_vsd_bil_gt4 = 1;
2550                         cbcr_vsd_bil_gt2 = 0;
2551                 } else if (cbcr_vscalednmult == 2) {
2552                         cbcr_vsd_bil_gt4 = 0;
2553                         cbcr_vsd_bil_gt2 = 1;
2554                 } else {
2555                         cbcr_vsd_bil_gt4 = 0;
2556                         cbcr_vsd_bil_gt2 = 0;
2557                 }
2558                 if ((win->area[0].format == YUYV420) ||
2559                     (win->area[0].format == UYVY420)) {
2560                         if ((cbcr_vsd_bil_gt4 == 1) || (cbcr_vsd_bil_gt2 == 1))
2561                                 win->cbr_vsd_mode = SCALE_DOWN_AVG;
2562                 }
2563                 /* CBCR vsd_mode must same to YRGB for YUYV when gt2 or gt4 */
2564                 if ((cbcr_vsd_bil_gt4 == 1) || (cbcr_vsd_bil_gt2 == 1)) {
2565                         if (win->yrgb_vsd_mode != win->cbr_vsd_mode)
2566                                 win->cbr_vsd_mode = win->yrgb_vsd_mode;
2567                 }
2568         }
2569         /* 3399 yuyv support*/
2570         if (win->ymirror == 1) {
2571                 if (win->yrgb_vsd_mode == SCALE_DOWN_AVG)
2572                         pr_info("y_mirror enable, y-vsd AVG mode unsupprot\n");
2573                 win->yrgb_vsd_mode = SCALE_DOWN_BIL;
2574         }
2575         if (screen->mode.vmode & FB_VMODE_INTERLACED) {
2576                 if (win->yrgb_vsd_mode == SCALE_DOWN_AVG)
2577                         pr_info("interlace mode, y-vsd AVG mode unsupprot\n");
2578                 /* interlace mode must bill */
2579                 win->yrgb_vsd_mode = SCALE_DOWN_BIL;
2580                 win->cbr_vsd_mode = SCALE_DOWN_BIL;
2581         }
2582         switch (win->win_lb_mode) {
2583         case LB_YUV_3840X5:
2584         case LB_YUV_2560X8:
2585         case LB_RGB_1920X5:
2586         case LB_RGB_1280X8:
2587                 win->yrgb_vsu_mode = SCALE_UP_BIC;
2588                 win->cbr_vsu_mode = SCALE_UP_BIC;
2589                 break;
2590         case LB_RGB_3840X2:
2591                 if (win->yrgb_ver_scl_mode != SCALE_NONE)
2592                         pr_err("ERROR : not allow yrgb ver scale\n");
2593                 if (win->cbr_ver_scl_mode != SCALE_NONE)
2594                         pr_err("ERROR : not allow cbcr ver scale\n");
2595                 break;
2596         case LB_RGB_2560X4:
2597                 win->yrgb_vsu_mode = SCALE_UP_BIL;
2598                 win->cbr_vsu_mode = SCALE_UP_BIL;
2599                 break;
2600         default:
2601                 pr_info("%s:un supported win_lb_mode:%d\n",
2602                         __func__, win->win_lb_mode);
2603                 break;
2604         }
2605
2606         if ((win->yrgb_ver_scl_mode == SCALE_DOWN) &&
2607             (win->area[0].fbdc_en == 1)) {
2608                 /* in this pattern,use bil mode,not support souble scd,
2609                  * use avg mode, support double scd, but aclk should be
2610                  * bigger than dclk.
2611                  */
2612                 if (yrgb_srcH >= 2 * yrgb_dstH) {
2613                         pr_err("ERROR : fbdc mode,not support y scale down:");
2614                         pr_err("srcH[%d] > 2 *dstH[%d]\n",
2615                                yrgb_srcH, yrgb_dstH);
2616                 }
2617         }
2618         DBG(1, "yrgb:hsd=%d,vsd=%d,vsu=%d;cbcr:hsd=%d,vsd=%d,vsu=%d\n",
2619             win->yrgb_hsd_mode, win->yrgb_vsd_mode, win->yrgb_vsu_mode,
2620             win->cbr_hsd_mode, win->cbr_vsd_mode, win->cbr_vsu_mode);
2621
2622         /* SCALE FACTOR */
2623
2624         /* (1.1)YRGB HOR SCALE FACTOR */
2625         switch (win->yrgb_hor_scl_mode) {
2626         case SCALE_NONE:
2627                 yrgb_xscl_factor = (1 << SCALE_FACTOR_DEFAULT_FIXPOINT_SHIFT);
2628                 break;
2629         case SCALE_UP:
2630                 yrgb_xscl_factor = GET_SCALE_FACTOR_BIC(yrgb_srcW, yrgb_dstW);
2631                 break;
2632         case SCALE_DOWN:
2633                 switch (win->yrgb_hsd_mode) {
2634                 case SCALE_DOWN_BIL:
2635                         yrgb_xscl_factor =
2636                             GET_SCALE_FACTOR_BILI_DN(yrgb_srcW, yrgb_dstW);
2637                         break;
2638                 case SCALE_DOWN_AVG:
2639                         yrgb_xscl_factor =
2640                             GET_SCALE_FACTOR_AVRG(yrgb_srcW, yrgb_dstW);
2641                         break;
2642                 default:
2643                         pr_info("%s:un supported yrgb_hsd_mode:%d\n", __func__,
2644                                 win->yrgb_hsd_mode);
2645                         break;
2646                 }
2647                 break;
2648         default:
2649                 pr_info("%s:un supported yrgb_hor_scl_mode:%d\n",
2650                         __func__, win->yrgb_hor_scl_mode);
2651                 break;
2652         }
2653
2654         /* (1.2)YRGB VER SCALE FACTOR */
2655         switch (win->yrgb_ver_scl_mode) {
2656         case SCALE_NONE:
2657                 yrgb_yscl_factor = (1 << SCALE_FACTOR_DEFAULT_FIXPOINT_SHIFT);
2658                 break;
2659         case SCALE_UP:
2660                 switch (win->yrgb_vsu_mode) {
2661                 case SCALE_UP_BIL:
2662                         yrgb_yscl_factor =
2663                             GET_SCALE_FACTOR_BILI_UP(yrgb_srcH, yrgb_dstH);
2664                         break;
2665                 case SCALE_UP_BIC:
2666                         if (yrgb_srcH < 3) {
2667                                 pr_err("yrgb_srcH should be");
2668                                 pr_err(" greater than 3 !!!\n");
2669                         }
2670                         yrgb_yscl_factor = GET_SCALE_FACTOR_BIC(yrgb_srcH,
2671                                                                 yrgb_dstH);
2672                         break;
2673                 default:
2674                         pr_info("%s:un support yrgb_vsu_mode:%d\n",
2675                                 __func__, win->yrgb_vsu_mode);
2676                         break;
2677                 }
2678                 break;
2679         case SCALE_DOWN:
2680                 switch (win->yrgb_vsd_mode) {
2681                 case SCALE_DOWN_BIL:
2682                         yrgb_vscalednmult =
2683                             vop_get_hard_ware_vskiplines(yrgb_srcH, yrgb_dstH);
2684                         yrgb_yscl_factor =
2685                             GET_SCALE_FACTOR_BILI_DN_VSKIP(yrgb_srcH, yrgb_dstH,
2686                                                            yrgb_vscalednmult);
2687                         if (yrgb_yscl_factor >= 0x2000) {
2688                                 pr_err("yrgb_yscl_factor should less 0x2000");
2689                                 pr_err("yrgb_yscl_factor=%4x;\n",
2690                                        yrgb_yscl_factor);
2691                         }
2692                         if (yrgb_vscalednmult == 4) {
2693                                 yrgb_vsd_bil_gt4 = 1;
2694                                 yrgb_vsd_bil_gt2 = 0;
2695                         } else if (yrgb_vscalednmult == 2) {
2696                                 yrgb_vsd_bil_gt4 = 0;
2697                                 yrgb_vsd_bil_gt2 = 1;
2698                         } else {
2699                                 yrgb_vsd_bil_gt4 = 0;
2700                                 yrgb_vsd_bil_gt2 = 0;
2701                         }
2702                         break;
2703                 case SCALE_DOWN_AVG:
2704                         yrgb_yscl_factor = GET_SCALE_FACTOR_AVRG(yrgb_srcH,
2705                                                                  yrgb_dstH);
2706                         break;
2707                 default:
2708                         pr_info("%s:un support yrgb_vsd_mode:%d\n",
2709                                 __func__, win->yrgb_vsd_mode);
2710                         break;
2711                 }               /*win->yrgb_vsd_mode */
2712                 break;
2713         default:
2714                 pr_info("%s:un supported yrgb_ver_scl_mode:%d\n",
2715                         __func__, win->yrgb_ver_scl_mode);
2716                 break;
2717         }
2718         win->scale_yrgb_x = yrgb_xscl_factor;
2719         win->scale_yrgb_y = yrgb_yscl_factor;
2720         win->vsd_yrgb_gt4 = yrgb_vsd_bil_gt4;
2721         win->vsd_yrgb_gt2 = yrgb_vsd_bil_gt2;
2722         DBG(1, "yrgb:h_fac=%d, V_fac=%d,gt4=%d, gt2=%d\n", yrgb_xscl_factor,
2723             yrgb_yscl_factor, yrgb_vsd_bil_gt4, yrgb_vsd_bil_gt2);
2724
2725         /*(2.1)CBCR HOR SCALE FACTOR */
2726         switch (win->cbr_hor_scl_mode) {
2727         case SCALE_NONE:
2728                 cbcr_xscl_factor = (1 << SCALE_FACTOR_DEFAULT_FIXPOINT_SHIFT);
2729                 break;
2730         case SCALE_UP:
2731                 cbcr_xscl_factor = GET_SCALE_FACTOR_BIC(cbcr_srcW, cbcr_dstW);
2732                 break;
2733         case SCALE_DOWN:
2734                 switch (win->cbr_hsd_mode) {
2735                 case SCALE_DOWN_BIL:
2736                         cbcr_xscl_factor =
2737                             GET_SCALE_FACTOR_BILI_DN(cbcr_srcW, cbcr_dstW);
2738                         break;
2739                 case SCALE_DOWN_AVG:
2740                         cbcr_xscl_factor =
2741                             GET_SCALE_FACTOR_AVRG(cbcr_srcW, cbcr_dstW);
2742                         break;
2743                 default:
2744                         pr_info("%s:un support cbr_hsd_mode:%d\n",
2745                                 __func__, win->cbr_hsd_mode);
2746                         break;
2747                 }
2748                 break;
2749         default:
2750                 pr_info("%s:un supported cbr_hor_scl_mode:%d\n",
2751                         __func__, win->cbr_hor_scl_mode);
2752                 break;
2753         }                       /*win->cbr_hor_scl_mode */
2754
2755         /* (2.2)CBCR VER SCALE FACTOR */
2756         switch (win->cbr_ver_scl_mode) {
2757         case SCALE_NONE:
2758                 cbcr_yscl_factor = (1 << SCALE_FACTOR_DEFAULT_FIXPOINT_SHIFT);
2759                 break;
2760         case SCALE_UP:
2761                 switch (win->cbr_vsu_mode) {
2762                 case SCALE_UP_BIL:
2763                         cbcr_yscl_factor =
2764                             GET_SCALE_FACTOR_BILI_UP(cbcr_srcH, cbcr_dstH);
2765                         break;
2766                 case SCALE_UP_BIC:
2767                         if (cbcr_srcH < 3) {
2768                                 pr_err("cbcr_srcH should be ");
2769                                 pr_err("greater than 3 !!!\n");
2770                         }
2771                         cbcr_yscl_factor = GET_SCALE_FACTOR_BIC(cbcr_srcH,
2772                                                                 cbcr_dstH);
2773                         break;
2774                 default:
2775                         pr_info("%s:un support cbr_vsu_mode:%d\n",
2776                                 __func__, win->cbr_vsu_mode);
2777                         break;
2778                 }
2779                 break;
2780         case SCALE_DOWN:
2781                 switch (win->cbr_vsd_mode) {
2782                 case SCALE_DOWN_BIL:
2783                         cbcr_vscalednmult =
2784                             vop_get_hard_ware_vskiplines(cbcr_srcH, cbcr_dstH);
2785                         cbcr_yscl_factor =
2786                             GET_SCALE_FACTOR_BILI_DN_VSKIP(cbcr_srcH, cbcr_dstH,
2787                                                            cbcr_vscalednmult);
2788                         if (cbcr_yscl_factor >= 0x2000) {
2789                                 pr_err("cbcr_yscl_factor should be less ");
2790                                 pr_err("than 0x2000,cbcr_yscl_factor=%4x;\n",
2791                                        cbcr_yscl_factor);
2792                         }
2793
2794                         if (cbcr_vscalednmult == 4) {
2795                                 cbcr_vsd_bil_gt4 = 1;
2796                                 cbcr_vsd_bil_gt2 = 0;
2797                         } else if (cbcr_vscalednmult == 2) {
2798                                 cbcr_vsd_bil_gt4 = 0;
2799                                 cbcr_vsd_bil_gt2 = 1;
2800                         } else {
2801                                 cbcr_vsd_bil_gt4 = 0;
2802                                 cbcr_vsd_bil_gt2 = 0;
2803                         }
2804                         break;
2805                 case SCALE_DOWN_AVG:
2806                         cbcr_yscl_factor = GET_SCALE_FACTOR_AVRG(cbcr_srcH,
2807                                                                  cbcr_dstH);
2808                         break;
2809                 default:
2810                         pr_info("%s:un support cbr_vsd_mode:%d\n",
2811                                 __func__, win->cbr_vsd_mode);
2812                         break;
2813                 }
2814                 break;
2815         default:
2816                 pr_info("%s:un supported cbr_ver_scl_mode:%d\n",
2817                         __func__, win->cbr_ver_scl_mode);
2818                 break;
2819         }
2820         win->scale_cbcr_x = cbcr_xscl_factor;
2821         win->scale_cbcr_y = cbcr_yscl_factor;
2822         win->vsd_cbr_gt4 = cbcr_vsd_bil_gt4;
2823         win->vsd_cbr_gt2 = cbcr_vsd_bil_gt2;
2824
2825         DBG(1, "cbcr:h_fac=%d,v_fac=%d,gt4=%d,gt2=%d\n", cbcr_xscl_factor,
2826             cbcr_yscl_factor, cbcr_vsd_bil_gt4, cbcr_vsd_bil_gt2);
2827         return 0;
2828 }
2829
2830 static int dsp_x_pos(int mirror_en, struct rk_screen *screen,
2831                      struct rk_lcdc_win_area *area)
2832 {
2833         int pos;
2834
2835         if (screen->x_mirror && mirror_en)
2836                 pr_err("not support both win and global mirror\n");
2837
2838         if ((!mirror_en) && (!screen->x_mirror))
2839                 pos = area->xpos + screen->mode.left_margin +
2840                         screen->mode.hsync_len;
2841         else
2842                 pos = screen->mode.xres - area->xpos -
2843                         area->xsize + screen->mode.left_margin +
2844                         screen->mode.hsync_len;
2845
2846         return pos;
2847 }
2848
2849 static int dsp_y_pos(int mirror_en, struct rk_screen *screen,
2850                      struct rk_lcdc_win_area *area)
2851 {
2852         int pos;
2853
2854         if (screen->y_mirror && mirror_en)
2855                 pr_err("not support both win and global mirror\n");
2856
2857         if ((!mirror_en) && (!screen->y_mirror))
2858                 pos = area->ypos + screen->mode.upper_margin +
2859                         screen->mode.vsync_len;
2860         else
2861                 pos = screen->mode.yres - area->ypos -
2862                         area->ysize + screen->mode.upper_margin +
2863                         screen->mode.vsync_len;
2864
2865         return pos;
2866 }
2867
2868 static int win_0_1_set_par(struct vop_device *vop_dev,
2869                            struct rk_screen *screen, struct rk_lcdc_win *win)
2870 {
2871         u32 xact = 0, yact = 0, xvir = 0, yvir = 0, xpos = 0, ypos = 0;
2872         u8 fmt_cfg = 0, swap_rb = 0, swap_uv = 0;
2873         char fmt[9] = "NULL";
2874
2875         xpos = dsp_x_pos(win->xmirror, screen, &win->area[0]);
2876         ypos = dsp_y_pos(win->ymirror, screen, &win->area[0]);
2877
2878         spin_lock(&vop_dev->reg_lock);
2879         if (likely(vop_dev->clk_on)) {
2880                 vop_cal_scl_fac(win, screen);
2881                 switch (win->area[0].format) {
2882                 case FBDC_RGB_565:
2883                         fmt_cfg = 2;
2884                         swap_rb = 0;
2885                         win->fmt_10 = 0;
2886                         win->area[0].fbdc_fmt_cfg = AFBDC_FMT_RGB565;
2887                         break;
2888                 case FBDC_ARGB_888:
2889                         fmt_cfg = 0;
2890                         swap_rb = 1;
2891                         win->fmt_10 = 0;
2892                         win->area[0].fbdc_fmt_cfg = AFBDC_FMT_U8U8U8U8;
2893                         break;
2894                 case FBDC_ABGR_888:
2895                         fmt_cfg = 0;
2896                         swap_rb = 0;
2897                         win->fmt_10 = 0;
2898                         win->area[0].fbdc_fmt_cfg = AFBDC_FMT_U8U8U8U8;
2899                         break;
2900                 case FBDC_RGBX_888:
2901                         fmt_cfg = 0;
2902                         swap_rb = 0;
2903                         win->fmt_10 = 0;
2904                         win->area[0].fbdc_fmt_cfg = AFBDC_FMT_U8U8U8U8;
2905                         break;
2906                 case ARGB888:
2907                         fmt_cfg = 0;
2908                         swap_rb = 0;
2909                         win->fmt_10 = 0;
2910                         break;
2911                 case XBGR888:
2912                 case ABGR888:
2913                         fmt_cfg = 0;
2914                         swap_rb = 1;
2915                         win->fmt_10 = 0;
2916                         break;
2917                 case BGR888:
2918                         fmt_cfg = 1;
2919                         swap_rb = 1;
2920                         win->fmt_10 = 0;
2921                         break;
2922                 case RGB888:
2923                         fmt_cfg = 1;
2924                         swap_rb = 0;
2925                         win->fmt_10 = 0;
2926                         break;
2927                 case RGB565:
2928                         fmt_cfg = 2;
2929                         swap_rb = 0;
2930                         win->fmt_10 = 0;
2931                         break;
2932                 case YUV422:
2933                         fmt_cfg = 5;
2934                         swap_rb = 0;
2935                         win->fmt_10 = 0;
2936                         break;
2937                 case YUV420:
2938                         fmt_cfg = 4;
2939                         swap_rb = 0;
2940                         win->fmt_10 = 0;
2941                         break;
2942                 case YUV420_NV21:
2943                         fmt_cfg = 4;
2944                         swap_rb = 0;
2945                         swap_uv = 1;
2946                         win->fmt_10 = 0;
2947                         break;
2948                 case YUV444:
2949                         fmt_cfg = 6;
2950                         swap_rb = 0;
2951                         win->fmt_10 = 0;
2952                         break;
2953                 case YUV422_A:
2954                         fmt_cfg = 5;
2955                         swap_rb = 0;
2956                         win->fmt_10 = 1;
2957                         break;
2958                 case YUV420_A:
2959                         fmt_cfg = 4;
2960                         swap_rb = 0;
2961                         win->fmt_10 = 1;
2962                         break;
2963                 case YUV444_A:
2964                         fmt_cfg = 6;
2965                         swap_rb = 0;
2966                         win->fmt_10 = 1;
2967                         break;
2968                 case YUYV422:
2969                         fmt_cfg = 0;
2970                         swap_rb = 0;
2971                         win->fmt_10 = 0;
2972                         win->area[0].yuyv_fmt = 1;
2973                         break;
2974                 case YUYV420:
2975                         fmt_cfg = 1;
2976                         swap_rb = 0;
2977                         win->fmt_10 = 0;
2978                         win->area[0].yuyv_fmt = 1;
2979                         break;
2980                 case UYVY422:
2981                         fmt_cfg = 2;
2982                         swap_rb = 0;
2983                         win->fmt_10 = 0;
2984                         win->area[0].yuyv_fmt = 1;
2985                         break;
2986                 case UYVY420:
2987                         fmt_cfg = 3;
2988                         swap_rb = 0;
2989                         win->fmt_10 = 0;
2990                         win->area[0].yuyv_fmt = 1;
2991                         break;
2992                 default:
2993                         dev_err(vop_dev->dev, "%s:unsupport format[%d]!\n",
2994                                 __func__, win->area[0].format);
2995                         break;
2996                 }
2997                 win->area[0].fmt_cfg = fmt_cfg;
2998                 win->area[0].swap_rb = swap_rb;
2999                 win->area[0].swap_uv = swap_uv;
3000                 win->area[0].dsp_stx = xpos;
3001                 win->area[0].dsp_sty = ypos;
3002                 xact = win->area[0].xact;
3003                 yact = win->area[0].yact;
3004                 xvir = win->area[0].xvir;
3005                 yvir = win->area[0].yvir;
3006         }
3007         if (win->area[0].fbdc_en)
3008                 vop_init_fbdc_config(vop_dev, win->id);
3009         vop_win_0_1_reg_update(&vop_dev->driver, win->id);
3010         spin_unlock(&vop_dev->reg_lock);
3011
3012         DBG(1, "lcdc[%d]:win[%d]\n>>format:%s>>>xact:%d>>yact:%d>>xsize:%d",
3013             vop_dev->id, win->id, get_format_string(win->area[0].format, fmt),
3014             xact, yact, win->area[0].xsize);
3015         DBG(1, ">>ysize:%d>>xvir:%d>>yvir:%d>>xpos:%d>>ypos:%d>>\n",
3016             win->area[0].ysize, xvir, yvir, xpos, ypos);
3017
3018         return 0;
3019 }
3020
3021 static int win_2_3_set_par(struct vop_device *vop_dev,
3022                            struct rk_screen *screen, struct rk_lcdc_win *win)
3023 {
3024         int i;
3025         u8 fmt_cfg = 0, swap_rb = 0;
3026         char fmt[9] = "NULL";
3027
3028         if (VOP_CHIP(vop_dev) == VOP_RK322X) {
3029                 pr_err("rk3228 not support win2/3 set par\n");
3030                 return -EINVAL;
3031         }
3032         if (win->ymirror) {
3033                 pr_err("win[%d] not support y mirror\n", win->id);
3034                 return -EINVAL;
3035         }
3036         spin_lock(&vop_dev->reg_lock);
3037         if (likely(vop_dev->clk_on)) {
3038                 DBG(2, "lcdc[%d]:win[%d]>>\n>\n", vop_dev->id, win->id);
3039                 for (i = 0; i < win->area_num; i++) {
3040                         switch (win->area[i].format) {
3041                         case FBDC_RGB_565:
3042                                 fmt_cfg = 2;
3043                                 swap_rb = 0;
3044                                 win->fmt_10 = 0;
3045                                 win->area[0].fbdc_fmt_cfg = 0x05;
3046                                 break;
3047                         case FBDC_ARGB_888:
3048                                 fmt_cfg = 0;
3049                                 swap_rb = 0;
3050                                 win->fmt_10 = 0;
3051                                 win->area[0].fbdc_fmt_cfg = 0x0c;
3052                                 break;
3053                         case FBDC_RGBX_888:
3054                                 fmt_cfg = 0;
3055                                 swap_rb = 0;
3056                                 win->fmt_10 = 0;
3057                                 win->area[0].fbdc_fmt_cfg = 0x3a;
3058                                 break;
3059                         case ARGB888:
3060                                 fmt_cfg = 0;
3061                                 swap_rb = 0;
3062                                 break;
3063                         case XBGR888:
3064                         case ABGR888:
3065                                 fmt_cfg = 0;
3066                                 swap_rb = 1;
3067                                 break;
3068                         case RGB888:
3069                                 fmt_cfg = 1;
3070                                 swap_rb = 0;
3071                                 break;
3072                         case RGB565:
3073                                 fmt_cfg = 2;
3074                                 swap_rb = 0;
3075                                 break;
3076                         default:
3077                                 dev_err(vop_dev->driver.dev,
3078                                         "%s:un supported format!\n", __func__);
3079                                 spin_unlock(&vop_dev->reg_lock);
3080                                 return -EINVAL;
3081                         }
3082                         win->area[i].fmt_cfg = fmt_cfg;
3083                         win->area[i].swap_rb = swap_rb;
3084                         win->area[i].dsp_stx = dsp_x_pos(win->xmirror, screen,
3085                                                          &win->area[i]);
3086                         win->area[i].dsp_sty = dsp_y_pos(win->ymirror, screen,
3087                                                          &win->area[i]);
3088                         if (((win->area[i].xact != win->area[i].xsize) ||
3089                              (win->area[i].yact != win->area[i].ysize)) &&
3090                             (screen->mode.vmode == FB_VMODE_NONINTERLACED)) {
3091                                 pr_err("win[%d]->area[%d],not support scale\n",
3092                                        win->id, i);
3093                                 pr_err("xact=%d,yact=%d,xsize=%d,ysize=%d\n",
3094                                        win->area[i].xact, win->area[i].yact,
3095                                        win->area[i].xsize, win->area[i].ysize);
3096                                 win->area[i].xsize = win->area[i].xact;
3097                                 win->area[i].ysize = win->area[i].yact;
3098                         }
3099                         DBG(2, "fmt:%s:xsize:%d>>ysize:%d>>xpos:%d>>ypos:%d\n",
3100                             get_format_string(win->area[i].format, fmt),
3101                             win->area[i].xsize, win->area[i].ysize,
3102                             win->area[i].xpos, win->area[i].ypos);
3103                 }
3104         }
3105         if (win->area[0].fbdc_en)
3106                 vop_init_fbdc_config(vop_dev, win->id);
3107         vop_win_2_3_reg_update(&vop_dev->driver, win->id);
3108         spin_unlock(&vop_dev->reg_lock);
3109         return 0;
3110 }
3111
3112 static int hwc_set_par(struct vop_device *vop_dev,
3113                        struct rk_screen *screen, struct rk_lcdc_win *win)
3114 {
3115         u32 xact = 0, yact = 0, xvir = 0, yvir = 0, xpos = 0, ypos = 0;
3116         u8 fmt_cfg = 0, swap_rb = 0;
3117         char fmt[9] = "NULL";
3118
3119         xpos = win->area[0].xpos + screen->mode.left_margin +
3120             screen->mode.hsync_len;
3121         ypos = win->area[0].ypos + screen->mode.upper_margin +
3122             screen->mode.vsync_len;
3123
3124         spin_lock(&vop_dev->reg_lock);
3125         if (likely(vop_dev->clk_on)) {
3126                 switch (win->area[0].format) {
3127                 case ARGB888:
3128                         fmt_cfg = 0;
3129                         swap_rb = 0;
3130                         break;
3131                 case XBGR888:
3132                 case ABGR888:
3133                         fmt_cfg = 0;
3134                         swap_rb = 1;
3135                         break;
3136                 case RGB888:
3137                         fmt_cfg = 1;
3138                         swap_rb = 0;
3139                         break;
3140                 case RGB565:
3141                         fmt_cfg = 2;
3142                         swap_rb = 0;
3143                         break;
3144                 default:
3145                         dev_err(vop_dev->dev, "%s:un supported format[%d]!\n",
3146                                 __func__, win->area[0].format);
3147                         break;
3148                 }
3149                 win->area[0].fmt_cfg = fmt_cfg;
3150                 win->area[0].swap_rb = swap_rb;
3151                 win->area[0].dsp_stx = xpos;
3152                 win->area[0].dsp_sty = ypos;
3153                 xact = win->area[0].xact;
3154                 yact = win->area[0].yact;
3155                 xvir = win->area[0].xvir;
3156                 yvir = win->area[0].yvir;
3157         }
3158         vop_hwc_reg_update(&vop_dev->driver, 4);
3159         spin_unlock(&vop_dev->reg_lock);
3160
3161         DBG(1, "lcdc[%d]:hwc>>%s\n>>format:%s>>>xact:%d>>yact:%d>>xsize:%d",
3162             vop_dev->id, __func__, get_format_string(win->area[0].format, fmt),
3163             xact, yact, win->area[0].xsize);
3164         DBG(1, ">>ysize:%d>>xvir:%d>>yvir:%d>>xpos:%d>>ypos:%d>>\n",
3165             win->area[0].ysize, xvir, yvir, xpos, ypos);
3166         return 0;
3167 }
3168
3169 static int vop_set_par(struct rk_lcdc_driver *dev_drv, int win_id)
3170 {
3171         struct vop_device *vop_dev =
3172             container_of(dev_drv, struct vop_device, driver);
3173         struct rk_lcdc_win *win = NULL;
3174         struct rk_screen *screen = dev_drv->cur_screen;
3175
3176         if (unlikely(!vop_dev->clk_on)) {
3177                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
3178                 return 0;
3179         }
3180         win = dev_drv->win[win_id];
3181         if (win)
3182         switch (win_id) {
3183         case 0:
3184                 win_0_1_set_par(vop_dev, screen, win);
3185                 break;
3186         case 1:
3187                 win_0_1_set_par(vop_dev, screen, win);
3188                 break;
3189         case 2:
3190                 win_2_3_set_par(vop_dev, screen, win);
3191                 break;
3192         case 3:
3193                 win_2_3_set_par(vop_dev, screen, win);
3194                 break;
3195         case 4:
3196                 hwc_set_par(vop_dev, screen, win);
3197                 break;
3198         default:
3199                 dev_err(dev_drv->dev, "unsupported win number:%d\n", win_id);
3200                 break;
3201         }
3202         return 0;
3203 }
3204
3205 static int vop_set_writeback(struct rk_lcdc_driver *dev_drv)
3206 {
3207         struct vop_device *vop_dev =
3208             container_of(dev_drv, struct vop_device, driver);
3209         int output_color = dev_drv->output_color;
3210         struct rk_screen *screen = dev_drv->cur_screen;
3211         struct rk_fb_reg_wb_data *wb_data;
3212         int xact = screen->mode.xres;
3213         int yact = screen->mode.yres;
3214         u32 fmt_cfg;
3215         int xsize, ysize;
3216         u64 v;
3217
3218         if (unlikely(!vop_dev->clk_on)) {
3219                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
3220                 return 0;
3221         }
3222         wb_data = &dev_drv->wb_data;
3223         if ((wb_data->xsize == 0) || (wb_data->ysize == 0))
3224                 return 0;
3225
3226         xsize = wb_data->xsize;
3227         ysize = wb_data->ysize;
3228
3229         /*
3230          * RGB overlay mode support ARGB888, RGB888, RGB565, NV12,
3231          * but YUV overlay mode only support NV12, it's hard to judge RGB
3232          * or YUV overlay mode by userspace, so here force only support
3233          * NV12 mode.
3234          */
3235         if (wb_data->data_format != YUV420 && output_color != COLOR_RGB) {
3236                 pr_err("writeback only support NV12 when overlay is not RGB\n");
3237                 return -EINVAL;
3238         }
3239
3240         if (ysize != yact && ysize != (yact / 2)) {
3241                 pr_err("WriteBack only support yact=%d, ysize=%d\n",
3242                        yact, ysize);
3243                 return -EINVAL;
3244         }
3245
3246         switch (wb_data->data_format) {
3247         case ARGB888:
3248         case ABGR888:
3249         case XRGB888:
3250         case XBGR888:
3251                 fmt_cfg = 0;
3252                 break;
3253         case RGB888:
3254         case BGR888:
3255                 fmt_cfg = 1;
3256                 break;
3257         case RGB565:
3258         case BGR565:
3259                 fmt_cfg = 2;
3260                 break;
3261         case YUV420:
3262                 fmt_cfg = 8;
3263                 break;
3264         default:
3265                 pr_info("unsupport fmt: %d\n", wb_data->data_format);
3266                 return -EINVAL;
3267         }
3268
3269         v = V_WB_EN(wb_data->state) | V_WB_FMT(fmt_cfg) | V_WB_RGB2YUV_MODE(1) |
3270                 V_WB_XPSD_BIL_EN(xact != xsize) |
3271                 V_WB_YTHROW_EN(ysize == (yact / 2)) |
3272                 V_WB_YTHROW_MODE(0);
3273
3274         v |= V_WB_RGB2YUV_EN((output_color == COLOR_RGB) &&
3275                              (wb_data->data_format == YUV420));
3276
3277         vop_msk_reg(vop_dev, WB_CTRL0, v);
3278
3279         v = V_WB_WIDTH(xsize) | V_WB_XPSD_BIL_FACTOR((xact << 12) / xsize);
3280
3281         vop_msk_reg(vop_dev, WB_CTRL1, v);
3282
3283         vop_writel(vop_dev, WB_YRGB_MST, wb_data->smem_start);
3284         if (wb_data->data_format == YUV420)
3285                 vop_writel(vop_dev, WB_CBR_MST, wb_data->smem_start);
3286
3287         return 0;
3288 }
3289
3290 static int vop_ioctl(struct rk_lcdc_driver *dev_drv, unsigned int cmd,
3291                      unsigned long arg, int win_id)
3292 {
3293         struct vop_device *vop_dev =
3294                         container_of(dev_drv, struct vop_device, driver);
3295         u32 panel_size[2];
3296         void __user *argp = (void __user *)arg;
3297         struct color_key_cfg clr_key_cfg;
3298
3299         switch (cmd) {
3300         case RK_FBIOGET_PANEL_SIZE:
3301                 panel_size[0] = vop_dev->screen->mode.xres;
3302                 panel_size[1] = vop_dev->screen->mode.yres;
3303                 if (copy_to_user(argp, panel_size, 8))
3304                         return -EFAULT;
3305                 break;
3306         case RK_FBIOPUT_COLOR_KEY_CFG:
3307                 if (copy_from_user(&clr_key_cfg, argp, sizeof(clr_key_cfg)))
3308                         return -EFAULT;
3309                 vop_clr_key_cfg(dev_drv);
3310                 vop_writel(vop_dev, WIN0_COLOR_KEY,
3311                            clr_key_cfg.win0_color_key_cfg);
3312                 vop_writel(vop_dev, WIN1_COLOR_KEY,
3313                            clr_key_cfg.win1_color_key_cfg);
3314                 break;
3315
3316         default:
3317                 break;
3318         }
3319         return 0;
3320 }
3321
3322 static int vop_get_backlight_device(struct rk_lcdc_driver *dev_drv)
3323 {
3324         struct vop_device *vop_dev = container_of(dev_drv,
3325                                                     struct vop_device, driver);
3326         struct device_node *backlight;
3327         struct property *prop;
3328         u32 *brightness_levels;
3329         u32 length, max, last;
3330
3331         if (vop_dev->backlight)
3332                 return 0;
3333         backlight = of_parse_phandle(vop_dev->dev->of_node, "backlight", 0);
3334         if (backlight) {
3335                 vop_dev->backlight = of_find_backlight_by_node(backlight);
3336                 if (!vop_dev->backlight)
3337                         dev_info(vop_dev->dev, "No find backlight device\n");
3338         } else {
3339                 dev_info(vop_dev->dev, "No find backlight device node\n");
3340         }
3341         prop = of_find_property(backlight, "brightness-levels", &length);
3342         if (!prop)
3343                 return -EINVAL;
3344         max = length / sizeof(u32);
3345         last = max - 1;
3346         brightness_levels = kmalloc(256, GFP_KERNEL);
3347         if (brightness_levels)
3348                 return -ENOMEM;
3349
3350         if (!of_property_read_u32_array(backlight, "brightness-levels",
3351                                         brightness_levels, max)) {
3352                 if (brightness_levels[0] > brightness_levels[last])
3353                         dev_drv->cabc_pwm_pol = 1;/*negative*/
3354                 else
3355                         dev_drv->cabc_pwm_pol = 0;/*positive*/
3356         } else {
3357                 dev_info(vop_dev->dev,
3358                          "Can not read brightness-levels value\n");
3359         }
3360
3361         kfree(brightness_levels);
3362
3363         return 0;
3364 }
3365
3366 static int vop_early_suspend(struct rk_lcdc_driver *dev_drv)
3367 {
3368         struct vop_device *vop_dev =
3369             container_of(dev_drv, struct vop_device, driver);
3370
3371         if (dev_drv->suspend_flag)
3372                 return 0;
3373
3374         dev_drv->suspend_flag = 1;
3375         /* ensure suspend_flag take effect on multi process */
3376         smp_wmb();
3377         flush_kthread_worker(&dev_drv->update_regs_worker);
3378
3379         if (dev_drv->trsm_ops && dev_drv->trsm_ops->disable)
3380                 dev_drv->trsm_ops->disable();
3381
3382         if (likely(vop_dev->clk_on)) {
3383                 spin_lock(&vop_dev->reg_lock);
3384                 vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_BLANK_EN(1));
3385                 vop_mask_writel(vop_dev, INTR_CLEAR0, INTR_MASK, INTR_MASK);
3386                 vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_OUT_ZERO(1));
3387                 vop_msk_reg(vop_dev, SYS_CTRL, V_VOP_STANDBY_EN(1));
3388                 vop_cfg_done(vop_dev);
3389
3390                 if (dev_drv->iommu_enabled && dev_drv->mmu_dev) {
3391                         mdelay(50);
3392                         rockchip_iovmm_deactivate(dev_drv->dev);
3393                 }
3394
3395                 spin_unlock(&vop_dev->reg_lock);
3396         }
3397
3398         vop_clk_disable(vop_dev);
3399         rk_disp_pwr_disable(dev_drv);
3400
3401         return 0;
3402 }
3403
3404 static int vop_early_resume(struct rk_lcdc_driver *dev_drv)
3405 {
3406         struct vop_device *vop_dev =
3407             container_of(dev_drv, struct vop_device, driver);
3408
3409         if (!dev_drv->suspend_flag)
3410                 return 0;
3411         rk_disp_pwr_enable(dev_drv);
3412
3413         vop_clk_enable(vop_dev);
3414         spin_lock(&vop_dev->reg_lock);
3415         memcpy(vop_dev->regs, vop_dev->regsbak, vop_dev->len);
3416         spin_unlock(&vop_dev->reg_lock);
3417
3418         vop_set_lut(dev_drv, dev_drv->cur_screen->dsp_lut);
3419         vop_set_cabc(dev_drv, dev_drv->cur_screen->cabc_lut);
3420         spin_lock(&vop_dev->reg_lock);
3421
3422         vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_OUT_ZERO(0));
3423         vop_msk_reg(vop_dev, SYS_CTRL, V_VOP_STANDBY_EN(0));
3424         vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_BLANK_EN(0));
3425         vop_cfg_done(vop_dev);
3426         spin_unlock(&vop_dev->reg_lock);
3427
3428         if (dev_drv->iommu_enabled && dev_drv->mmu_dev) {
3429                 /* win address maybe effect after next frame start,
3430                  * but mmu maybe effect right now, so we delay 50ms
3431                  */
3432                 mdelay(50);
3433                 rockchip_iovmm_activate(dev_drv->dev);
3434         }
3435
3436         dev_drv->suspend_flag = 0;
3437
3438         if (dev_drv->trsm_ops && dev_drv->trsm_ops->enable)
3439                 dev_drv->trsm_ops->enable();
3440
3441         return 0;
3442 }
3443
3444 static int vop_blank(struct rk_lcdc_driver *dev_drv, int win_id, int blank_mode)
3445 {
3446         switch (blank_mode) {
3447         case FB_BLANK_UNBLANK:
3448                 vop_early_resume(dev_drv);
3449                 break;
3450         case FB_BLANK_NORMAL:
3451                 vop_early_suspend(dev_drv);
3452                 break;
3453         default:
3454                 vop_early_suspend(dev_drv);
3455                 break;
3456         }
3457
3458         dev_info(dev_drv->dev, "blank mode:%d\n", blank_mode);
3459
3460         return 0;
3461 }
3462
3463 static int vop_get_win_state(struct rk_lcdc_driver *dev_drv,
3464                              int win_id, int area_id)
3465 {
3466         struct vop_device *vop_dev =
3467                         container_of(dev_drv, struct vop_device, driver);
3468         u32 area_status = 0, state = 0;
3469
3470         switch (win_id) {
3471         case 0:
3472                 area_status = vop_read_bit(vop_dev, WIN0_CTRL0, V_WIN0_EN(0));
3473                 break;
3474         case 1:
3475                 area_status = vop_read_bit(vop_dev, WIN1_CTRL0, V_WIN1_EN(0));
3476                 break;
3477         case 2:
3478                 if (area_id == 0)
3479                         area_status = vop_read_bit(vop_dev, WIN2_CTRL0,
3480                                                    V_WIN2_MST0_EN(0));
3481                 if (area_id == 1)
3482                         area_status = vop_read_bit(vop_dev, WIN2_CTRL0,
3483                                                    V_WIN2_MST1_EN(0));
3484                 if (area_id == 2)
3485                         area_status = vop_read_bit(vop_dev, WIN2_CTRL0,
3486                                                    V_WIN2_MST2_EN(0));
3487                 if (area_id == 3)
3488                         area_status = vop_read_bit(vop_dev, WIN2_CTRL0,
3489                                                    V_WIN2_MST3_EN(0));
3490                 break;
3491         case 3:
3492                 if (area_id == 0)
3493                         area_status = vop_read_bit(vop_dev, WIN3_CTRL0,
3494                                                    V_WIN3_MST0_EN(0));
3495                 if (area_id == 1)
3496                         area_status = vop_read_bit(vop_dev, WIN3_CTRL0,
3497                                                    V_WIN3_MST1_EN(0));
3498                 if (area_id == 2)
3499                         area_status = vop_read_bit(vop_dev, WIN3_CTRL0,
3500                                                    V_WIN3_MST2_EN(0));
3501                 if (area_id == 3)
3502                         area_status = vop_read_bit(vop_dev, WIN3_CTRL0,
3503                                                    V_WIN3_MST3_EN(0));
3504                 break;
3505         case 4:
3506                 area_status = vop_read_bit(vop_dev, HWC_CTRL0, V_HWC_EN(0));
3507                 break;
3508         default:
3509                 pr_err("!!!%s,win[%d]area[%d],unsupport!!!\n",
3510                        __func__, win_id, area_id);
3511                 break;
3512         }
3513
3514         state = (area_status > 0) ? 1 : 0;
3515         return state;
3516 }
3517
3518 static int vop_get_area_num(struct rk_lcdc_driver *dev_drv,
3519                             unsigned int *area_support)
3520 {
3521         struct vop_device *vop_dev =
3522             container_of(dev_drv, struct vop_device, driver);
3523
3524         area_support[0] = 1;
3525         area_support[1] = 1;
3526
3527         if (VOP_CHIP(vop_dev) == VOP_RK3399) {
3528                 area_support[2] = 4;
3529                 area_support[3] = 4;
3530         }
3531
3532         return 0;
3533 }
3534
3535 /*overlay will be do at regupdate*/
3536 static int vop_ovl_mgr(struct rk_lcdc_driver *dev_drv, int swap, bool set)
3537 {
3538         struct vop_device *vop_dev =
3539             container_of(dev_drv, struct vop_device, driver);
3540         struct rk_lcdc_win *win = NULL;
3541         int i, ovl = 0;
3542         u64 val;
3543         int z_order_num = 0;
3544         int layer0_sel = 0, layer1_sel = 1, layer2_sel = 2, layer3_sel = 3;
3545
3546         if (swap == 0) {
3547                 for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3548                         win = dev_drv->win[i];
3549                         if (win->state == 1)
3550                                 z_order_num++;
3551                 }
3552                 for (i = 0; i < dev_drv->lcdc_win_num; i++) {
3553                         win = dev_drv->win[i];
3554                         if (win->state == 0)
3555                                 win->z_order = z_order_num++;
3556                         switch (win->z_order) {
3557                         case 0:
3558                                 layer0_sel = win->id;
3559                                 break;
3560                         case 1:
3561                                 layer1_sel = win->id;
3562                                 break;
3563                         case 2:
3564                                 layer2_sel = win->id;
3565                                 break;
3566                         case 3:
3567                                 layer3_sel = win->id;
3568                                 break;
3569                         default:
3570                                 break;
3571                         }
3572                 }
3573         } else {
3574                 layer0_sel = swap % 10;
3575                 layer1_sel = swap / 10 % 10;
3576                 layer2_sel = swap / 100 % 10;
3577                 layer3_sel = swap / 1000;
3578         }
3579
3580         spin_lock(&vop_dev->reg_lock);
3581         if (vop_dev->clk_on) {
3582                 if (set) {
3583                         val = V_DSP_LAYER0_SEL(layer0_sel) |
3584                             V_DSP_LAYER1_SEL(layer1_sel) |
3585                             V_DSP_LAYER2_SEL(layer2_sel) |
3586                             V_DSP_LAYER3_SEL(layer3_sel);
3587                         vop_msk_reg(vop_dev, DSP_CTRL1, val);
3588                 } else {
3589                         layer0_sel = vop_read_bit(vop_dev, DSP_CTRL1,
3590                                                   V_DSP_LAYER0_SEL(0));
3591                         layer1_sel = vop_read_bit(vop_dev, DSP_CTRL1,
3592                                                   V_DSP_LAYER1_SEL(0));
3593                         layer2_sel = vop_read_bit(vop_dev, DSP_CTRL1,
3594                                                   V_DSP_LAYER2_SEL(0));
3595                         layer3_sel = vop_read_bit(vop_dev, DSP_CTRL1,
3596                                                   V_DSP_LAYER3_SEL(0));
3597                         ovl = layer3_sel * 1000 + layer2_sel * 100 +
3598                             layer1_sel * 10 + layer0_sel;
3599                 }
3600         } else {
3601                 ovl = -EPERM;
3602         }
3603         spin_unlock(&vop_dev->reg_lock);
3604
3605         return ovl;
3606 }
3607
3608 static char *vop_format_to_string(int format, char *fmt)
3609 {
3610         if (!fmt)
3611                 return NULL;
3612
3613         switch (format) {
3614         case 0:
3615                 strcpy(fmt, "ARGB888");
3616                 break;
3617         case 1:
3618                 strcpy(fmt, "RGB888");
3619                 break;
3620         case 2:
3621                 strcpy(fmt, "RGB565");
3622                 break;
3623         case 4:
3624                 strcpy(fmt, "YCbCr420");
3625                 break;
3626         case 5:
3627                 strcpy(fmt, "YCbCr422");
3628                 break;
3629         case 6:
3630                 strcpy(fmt, "YCbCr444");
3631         case 8:
3632                 strcpy(fmt, "YUYV422");
3633                 break;
3634         case 9:
3635                 strcpy(fmt, "YUYV420");
3636                 break;
3637         case 10:
3638                 strcpy(fmt, "UYVY422");
3639                 break;
3640         case 11:
3641                 strcpy(fmt, "UYVY420");
3642                 break;
3643         default:
3644                 strcpy(fmt, "invalid\n");
3645                 break;
3646         }
3647         return fmt;
3648 }
3649
3650 static ssize_t vop_get_disp_info(struct rk_lcdc_driver *dev_drv,
3651                                  char *buf, int win_id)
3652 {
3653         struct vop_device *vop_dev =
3654             container_of(dev_drv, struct vop_device, driver);
3655         struct rk_screen *screen = dev_drv->cur_screen;
3656         u16 hsync_len = screen->mode.hsync_len;
3657         u16 left_margin = screen->mode.left_margin;
3658         u16 vsync_len = screen->mode.vsync_len;
3659         u16 upper_margin = screen->mode.upper_margin;
3660         u32 h_pw_bp = hsync_len + left_margin;
3661         u32 v_pw_bp = vsync_len + upper_margin;
3662         u32 fmt_id;
3663         char format_w0[9] = "NULL";
3664         char format_w1[9] = "NULL";
3665         char format_w2_0[9] = "NULL";
3666         char format_w2_1[9] = "NULL";
3667         char format_w2_2[9] = "NULL";
3668         char format_w2_3[9] = "NULL";
3669         char format_w3_0[9] = "NULL";
3670         char format_w3_1[9] = "NULL";
3671         char format_w3_2[9] = "NULL";
3672         char format_w3_3[9] = "NULL";
3673         char dsp_buf[100];
3674         u32 win_ctrl, zorder, vir_info, act_info, dsp_info, dsp_st;
3675         u32 y_factor, uv_factor;
3676         u8 layer0_sel, layer1_sel, layer2_sel, layer3_sel;
3677         u8 w0_state, w1_state, w2_state, w3_state;
3678         u8 w2_0_state, w2_1_state, w2_2_state, w2_3_state;
3679         u8 w3_0_state, w3_1_state, w3_2_state, w3_3_state;
3680
3681         u32 w0_vir_y, w0_vir_uv, w0_act_x, w0_act_y, w0_dsp_x, w0_dsp_y;
3682         u32 w0_st_x = h_pw_bp, w0_st_y = v_pw_bp;
3683         u32 w1_vir_y, w1_vir_uv, w1_act_x, w1_act_y, w1_dsp_x, w1_dsp_y;
3684         u32 w1_st_x = h_pw_bp, w1_st_y = v_pw_bp;
3685         u32 w0_y_h_fac, w0_y_v_fac, w0_uv_h_fac, w0_uv_v_fac;
3686         u32 w1_y_h_fac, w1_y_v_fac, w1_uv_h_fac, w1_uv_v_fac;
3687
3688         u32 w2_0_vir_y, w2_1_vir_y, w2_2_vir_y, w2_3_vir_y;
3689         u32 w2_0_dsp_x, w2_1_dsp_x, w2_2_dsp_x, w2_3_dsp_x;
3690         u32 w2_0_dsp_y, w2_1_dsp_y, w2_2_dsp_y, w2_3_dsp_y;
3691         u32 w2_0_st_x = h_pw_bp, w2_1_st_x = h_pw_bp;
3692         u32 w2_2_st_x = h_pw_bp, w2_3_st_x = h_pw_bp;
3693         u32 w2_0_st_y = v_pw_bp, w2_1_st_y = v_pw_bp;
3694         u32 w2_2_st_y = v_pw_bp, w2_3_st_y = v_pw_bp;
3695
3696         u32 w3_0_vir_y, w3_1_vir_y, w3_2_vir_y, w3_3_vir_y;
3697         u32 w3_0_dsp_x, w3_1_dsp_x, w3_2_dsp_x, w3_3_dsp_x;
3698         u32 w3_0_dsp_y, w3_1_dsp_y, w3_2_dsp_y, w3_3_dsp_y;
3699         u32 w3_0_st_x = h_pw_bp, w3_1_st_x = h_pw_bp;
3700         u32 w3_2_st_x = h_pw_bp, w3_3_st_x = h_pw_bp;
3701         u32 w3_0_st_y = v_pw_bp, w3_1_st_y = v_pw_bp;
3702         u32 w3_2_st_y = v_pw_bp, w3_3_st_y = v_pw_bp;
3703         u32 dclk_freq;
3704         int size = 0;
3705
3706         dclk_freq = screen->mode.pixclock;
3707         /*vop_reg_dump(dev_drv); */
3708
3709         spin_lock(&vop_dev->reg_lock);
3710         if (vop_dev->clk_on) {
3711                 zorder = vop_readl(vop_dev, DSP_CTRL1);
3712                 layer0_sel = (zorder & MASK(DSP_LAYER0_SEL)) >> 8;
3713                 layer1_sel = (zorder & MASK(DSP_LAYER1_SEL)) >> 10;
3714                 layer2_sel = (zorder & MASK(DSP_LAYER2_SEL)) >> 12;
3715                 layer3_sel = (zorder & MASK(DSP_LAYER3_SEL)) >> 14;
3716                 /* WIN0 */
3717                 win_ctrl = vop_readl(vop_dev, WIN0_CTRL0);
3718                 w0_state = win_ctrl & MASK(WIN0_EN);
3719                 fmt_id = (win_ctrl & MASK(WIN0_DATA_FMT)) >> 1;
3720                 fmt_id |= (win_ctrl & MASK(WIN0_YUYV)) >> 14; /* yuyv*/
3721                 vop_format_to_string(fmt_id, format_w0);
3722                 vir_info = vop_readl(vop_dev, WIN0_VIR);
3723                 act_info = vop_readl(vop_dev, WIN0_ACT_INFO);
3724                 dsp_info = vop_readl(vop_dev, WIN0_DSP_INFO);
3725                 dsp_st = vop_readl(vop_dev, WIN0_DSP_ST);
3726                 y_factor = vop_readl(vop_dev, WIN0_SCL_FACTOR_YRGB);
3727                 uv_factor = vop_readl(vop_dev, WIN0_SCL_FACTOR_CBR);
3728                 w0_vir_y = vir_info & MASK(WIN0_VIR_STRIDE);
3729                 w0_vir_uv = (vir_info & MASK(WIN0_VIR_STRIDE_UV)) >> 16;
3730                 w0_act_x = (act_info & MASK(WIN0_ACT_WIDTH)) + 1;
3731                 w0_act_y = ((act_info & MASK(WIN0_ACT_HEIGHT)) >> 16) + 1;
3732                 w0_dsp_x = (dsp_info & MASK(WIN0_DSP_WIDTH)) + 1;
3733                 w0_dsp_y = ((dsp_info & MASK(WIN0_DSP_HEIGHT)) >> 16) + 1;
3734                 if (w0_state) {
3735                         w0_st_x = dsp_st & MASK(WIN0_DSP_XST);
3736                         w0_st_y = (dsp_st & MASK(WIN0_DSP_YST)) >> 16;
3737                 }
3738                 w0_y_h_fac = y_factor & MASK(WIN0_HS_FACTOR_YRGB);
3739                 w0_y_v_fac = (y_factor & MASK(WIN0_VS_FACTOR_YRGB)) >> 16;
3740                 w0_uv_h_fac = uv_factor & MASK(WIN0_HS_FACTOR_CBR);
3741                 w0_uv_v_fac = (uv_factor & MASK(WIN0_VS_FACTOR_CBR)) >> 16;
3742
3743                 /* WIN1 */
3744                 win_ctrl = vop_readl(vop_dev, WIN1_CTRL0);
3745                 w1_state = win_ctrl & MASK(WIN1_EN);
3746                 fmt_id = (win_ctrl & MASK(WIN1_DATA_FMT)) >> 1;
3747                 fmt_id |= (win_ctrl & MASK(WIN1_YUYV)) >> 14; /* yuyv*/
3748                 vop_format_to_string(fmt_id, format_w1);
3749                 vir_info = vop_readl(vop_dev, WIN1_VIR);
3750                 act_info = vop_readl(vop_dev, WIN1_ACT_INFO);
3751                 dsp_info = vop_readl(vop_dev, WIN1_DSP_INFO);
3752                 dsp_st = vop_readl(vop_dev, WIN1_DSP_ST);
3753                 y_factor = vop_readl(vop_dev, WIN1_SCL_FACTOR_YRGB);
3754                 uv_factor = vop_readl(vop_dev, WIN1_SCL_FACTOR_CBR);
3755                 w1_vir_y = vir_info & MASK(WIN1_VIR_STRIDE);
3756                 w1_vir_uv = (vir_info & MASK(WIN1_VIR_STRIDE_UV)) >> 16;
3757                 w1_act_x = (act_info & MASK(WIN1_ACT_WIDTH)) + 1;
3758                 w1_act_y = ((act_info & MASK(WIN1_ACT_HEIGHT)) >> 16) + 1;
3759                 w1_dsp_x = (dsp_info & MASK(WIN1_DSP_WIDTH)) + 1;
3760                 w1_dsp_y = ((dsp_info & MASK(WIN1_DSP_HEIGHT)) >> 16) + 1;
3761                 if (w1_state) {
3762                         w1_st_x = dsp_st & MASK(WIN1_DSP_XST);
3763                         w1_st_y = (dsp_st & MASK(WIN1_DSP_YST)) >> 16;
3764                 }
3765                 w1_y_h_fac = y_factor & MASK(WIN1_HS_FACTOR_YRGB);
3766                 w1_y_v_fac = (y_factor & MASK(WIN1_VS_FACTOR_YRGB)) >> 16;
3767                 w1_uv_h_fac = uv_factor & MASK(WIN1_HS_FACTOR_CBR);
3768                 w1_uv_v_fac = (uv_factor & MASK(WIN1_VS_FACTOR_CBR)) >> 16;
3769
3770                 /*WIN2 */
3771                 win_ctrl = vop_readl(vop_dev, WIN2_CTRL0);
3772                 w2_state = win_ctrl & MASK(WIN2_EN);
3773                 w2_0_state = (win_ctrl & 0x10) >> 4;
3774                 w2_1_state = (win_ctrl & 0x100) >> 8;
3775                 w2_2_state = (win_ctrl & 0x1000) >> 12;
3776                 w2_3_state = (win_ctrl & 0x10000) >> 16;
3777                 vir_info = vop_readl(vop_dev, WIN2_VIR0_1);
3778                 w2_0_vir_y = vir_info & MASK(WIN2_VIR_STRIDE0);
3779                 w2_1_vir_y = (vir_info & MASK(WIN2_VIR_STRIDE1)) >> 16;
3780                 vir_info = vop_readl(vop_dev, WIN2_VIR2_3);
3781                 w2_2_vir_y = vir_info & MASK(WIN2_VIR_STRIDE2);
3782                 w2_3_vir_y = (vir_info & MASK(WIN2_VIR_STRIDE3)) >> 16;
3783
3784                 fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT0)) >> 5;
3785                 vop_format_to_string(fmt_id, format_w2_0);
3786                 fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT1)) >> 9;
3787                 vop_format_to_string(fmt_id, format_w2_1);
3788                 fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT2)) >> 13;
3789                 vop_format_to_string(fmt_id, format_w2_2);
3790                 fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT3)) >> 17;
3791                 vop_format_to_string(fmt_id, format_w2_3);
3792
3793                 dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO0);
3794                 dsp_st = vop_readl(vop_dev, WIN2_DSP_ST0);
3795                 w2_0_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH0)) + 1;
3796                 w2_0_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT0)) >> 16) + 1;
3797                 if (w2_0_state) {
3798                         w2_0_st_x = dsp_st & MASK(WIN2_DSP_XST0);
3799                         w2_0_st_y = (dsp_st & MASK(WIN2_DSP_YST0)) >> 16;
3800                 }
3801                 dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO1);
3802                 dsp_st = vop_readl(vop_dev, WIN2_DSP_ST1);
3803                 w2_1_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH1)) + 1;
3804                 w2_1_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT1)) >> 16) + 1;
3805                 if (w2_1_state) {
3806                         w2_1_st_x = dsp_st & MASK(WIN2_DSP_XST1);
3807                         w2_1_st_y = (dsp_st & MASK(WIN2_DSP_YST1)) >> 16;
3808                 }
3809                 dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO2);
3810                 dsp_st = vop_readl(vop_dev, WIN2_DSP_ST2);
3811                 w2_2_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH2)) + 1;
3812                 w2_2_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT2)) >> 16) + 1;
3813                 if (w2_2_state) {
3814                         w2_2_st_x = dsp_st & MASK(WIN2_DSP_XST2);
3815                         w2_2_st_y = (dsp_st & MASK(WIN2_DSP_YST2)) >> 16;
3816                 }
3817                 dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO3);
3818                 dsp_st = vop_readl(vop_dev, WIN2_DSP_ST3);
3819                 w2_3_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH3)) + 1;
3820                 w2_3_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT3)) >> 16) + 1;
3821                 if (w2_3_state) {
3822                         w2_3_st_x = dsp_st & MASK(WIN2_DSP_XST3);
3823                         w2_3_st_y = (dsp_st & MASK(WIN2_DSP_YST3)) >> 16;
3824                 }
3825
3826                 /*WIN3 */
3827                 win_ctrl = vop_readl(vop_dev, WIN3_CTRL0);
3828                 w3_state = win_ctrl & MASK(WIN3_EN);
3829                 w3_0_state = (win_ctrl & 0x10) >> 4;
3830                 w3_1_state = (win_ctrl & 0x100) >> 8;
3831                 w3_2_state = (win_ctrl & 0x1000) >> 12;
3832                 w3_3_state = (win_ctrl & 0x10000) >> 16;
3833                 vir_info = vop_readl(vop_dev, WIN3_VIR0_1);
3834                 w3_0_vir_y = vir_info & MASK(WIN3_VIR_STRIDE0);
3835                 w3_1_vir_y = (vir_info & MASK(WIN3_VIR_STRIDE1)) >> 16;
3836                 vir_info = vop_readl(vop_dev, WIN3_VIR2_3);
3837                 w3_2_vir_y = vir_info & MASK(WIN3_VIR_STRIDE2);
3838                 w3_3_vir_y = (vir_info & MASK(WIN3_VIR_STRIDE3)) >> 16;
3839
3840                 fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT0)) >> 5;
3841                 vop_format_to_string(fmt_id, format_w3_0);
3842                 fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT1)) >> 9;
3843                 vop_format_to_string(fmt_id, format_w3_1);
3844                 fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT2)) >> 13;
3845                 vop_format_to_string(fmt_id, format_w3_2);
3846                 fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT3)) >> 17;
3847                 vop_format_to_string(fmt_id, format_w3_3);
3848
3849                 dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO0);
3850                 dsp_st = vop_readl(vop_dev, WIN3_DSP_ST0);
3851                 w3_0_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH0)) + 1;
3852                 w3_0_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT0)) >> 16) + 1;
3853                 if (w3_0_state) {
3854                         w3_0_st_x = dsp_st & MASK(WIN3_DSP_XST0);
3855                         w3_0_st_y = (dsp_st & MASK(WIN3_DSP_YST0)) >> 16;
3856                 }
3857                 dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO1);
3858                 dsp_st = vop_readl(vop_dev, WIN3_DSP_ST1);
3859                 w3_1_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH1)) + 1;
3860                 w3_1_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT1)) >> 16) + 1;
3861                 if (w3_1_state) {
3862                         w3_1_st_x = dsp_st & MASK(WIN3_DSP_XST1);
3863                         w3_1_st_y = (dsp_st & MASK(WIN3_DSP_YST1)) >> 16;
3864                 }
3865                 dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO2);
3866                 dsp_st = vop_readl(vop_dev, WIN3_DSP_ST2);
3867                 w3_2_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH2)) + 1;
3868                 w3_2_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT2)) >> 16) + 1;
3869                 if (w3_2_state) {
3870                         w3_2_st_x = dsp_st & MASK(WIN3_DSP_XST2);
3871                         w3_2_st_y = (dsp_st & MASK(WIN3_DSP_YST2)) >> 16;
3872                 }
3873                 dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO3);
3874                 dsp_st = vop_readl(vop_dev, WIN3_DSP_ST3);
3875                 w3_3_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH3)) + 1;
3876                 w3_3_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT3)) >> 16) + 1;
3877                 if (w3_3_state) {
3878                         w3_3_st_x = dsp_st & MASK(WIN3_DSP_XST3);
3879                         w3_3_st_y = (dsp_st & MASK(WIN3_DSP_YST3)) >> 16;
3880                 }
3881         } else {
3882                 spin_unlock(&vop_dev->reg_lock);
3883                 return -EPERM;
3884         }
3885         spin_unlock(&vop_dev->reg_lock);
3886         size += snprintf(dsp_buf, 80,
3887                 "z-order:\n  win[%d]\n  win[%d]\n  win[%d]\n  win[%d]\n",
3888                 layer3_sel, layer2_sel, layer1_sel, layer0_sel);
3889         strcat(buf, dsp_buf);
3890         memset(dsp_buf, 0, sizeof(dsp_buf));
3891         /* win0 */
3892         size += snprintf(dsp_buf, 80,
3893                  "win0:\n  state:%d, fmt:%7s\n  y_vir:%4d, uv_vir:%4d,",
3894                  w0_state, format_w0, w0_vir_y, w0_vir_uv);
3895         strcat(buf, dsp_buf);
3896         memset(dsp_buf, 0, sizeof(dsp_buf));
3897
3898         size += snprintf(dsp_buf, 80,
3899                  " x_act  :%5d, y_act  :%5d, dsp_x   :%5d, dsp_y   :%5d\n",
3900                  w0_act_x, w0_act_y, w0_dsp_x, w0_dsp_y);
3901         strcat(buf, dsp_buf);
3902         memset(dsp_buf, 0, sizeof(dsp_buf));
3903
3904         size += snprintf(dsp_buf, 80,
3905                  "  x_st :%4d, y_st  :%4d, y_h_fac:%5d, y_v_fac:%5d, ",
3906                  w0_st_x - h_pw_bp, w0_st_y - v_pw_bp, w0_y_h_fac, w0_y_v_fac);
3907         strcat(buf, dsp_buf);
3908         memset(dsp_buf, 0, sizeof(dsp_buf));
3909
3910         size += snprintf(dsp_buf, 80,
3911                  "uv_h_fac:%5d, uv_v_fac:%5d\n  y_addr:0x%08x,    uv_addr:0x%08x\n",
3912                  w0_uv_h_fac, w0_uv_v_fac, vop_readl(vop_dev, WIN0_YRGB_MST),
3913                  vop_readl(vop_dev, WIN0_CBR_MST));
3914         strcat(buf, dsp_buf);
3915         memset(dsp_buf, 0, sizeof(dsp_buf));
3916
3917         /* win1 */
3918         size += snprintf(dsp_buf, 80,
3919                  "win1:\n  state:%d, fmt:%7s\n  y_vir:%4d, uv_vir:%4d,",
3920                  w1_state, format_w1, w1_vir_y, w1_vir_uv);
3921         strcat(buf, dsp_buf);
3922         memset(dsp_buf, 0, sizeof(dsp_buf));
3923
3924         size += snprintf(dsp_buf, 80,
3925                  " x_act  :%5d, y_act  :%5d, dsp_x   :%5d, dsp_y   :%5d\n",
3926                  w1_act_x, w1_act_y, w1_dsp_x, w1_dsp_y);
3927         strcat(buf, dsp_buf);
3928         memset(dsp_buf, 0, sizeof(dsp_buf));
3929
3930         size += snprintf(dsp_buf, 80,
3931                  "  x_st :%4d, y_st  :%4d, y_h_fac:%5d, y_v_fac:%5d, ",
3932                  w1_st_x - h_pw_bp, w1_st_y - v_pw_bp, w1_y_h_fac, w1_y_v_fac);
3933         strcat(buf, dsp_buf);
3934         memset(dsp_buf, 0, sizeof(dsp_buf));
3935
3936         size += snprintf(dsp_buf, 80,
3937                  "uv_h_fac:%5d, uv_v_fac:%5d\n  y_addr:0x%08x,    uv_addr:0x%08x\n",
3938                  w1_uv_h_fac, w1_uv_v_fac, vop_readl(vop_dev, WIN1_YRGB_MST),
3939                  vop_readl(vop_dev, WIN1_CBR_MST));
3940         strcat(buf, dsp_buf);
3941         memset(dsp_buf, 0, sizeof(dsp_buf));
3942
3943         /*win2*/
3944         size += snprintf(dsp_buf, 80,
3945                  "win2:\n  state:%d\n",
3946                  w2_state);
3947         strcat(buf, dsp_buf);
3948         memset(dsp_buf, 0, sizeof(dsp_buf));
3949         /*area 0*/
3950         size += snprintf(dsp_buf, 80,
3951                  "  area0: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
3952                  w2_0_state, format_w2_0, w2_0_dsp_x, w2_0_dsp_y);
3953         strcat(buf, dsp_buf);
3954         memset(dsp_buf, 0, sizeof(dsp_buf));
3955         size += snprintf(dsp_buf, 80,
3956                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
3957                  w2_0_st_x - h_pw_bp, w2_0_st_y - v_pw_bp,
3958                  vop_readl(vop_dev, WIN2_MST0));
3959         strcat(buf, dsp_buf);
3960         memset(dsp_buf, 0, sizeof(dsp_buf));
3961
3962         /*area 1*/
3963         size += snprintf(dsp_buf, 80,
3964                  "  area1: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
3965                  w2_1_state, format_w2_1, w2_1_dsp_x, w2_1_dsp_y);
3966         strcat(buf, dsp_buf);
3967         memset(dsp_buf, 0, sizeof(dsp_buf));
3968         size += snprintf(dsp_buf, 80,
3969                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
3970                  w2_1_st_x - h_pw_bp, w2_1_st_y - v_pw_bp,
3971                  vop_readl(vop_dev, WIN2_MST1));
3972         strcat(buf, dsp_buf);
3973         memset(dsp_buf, 0, sizeof(dsp_buf));
3974
3975         /*area 2*/
3976         size += snprintf(dsp_buf, 80,
3977                  "  area2: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
3978                  w2_2_state, format_w2_2, w2_2_dsp_x, w2_2_dsp_y);
3979         strcat(buf, dsp_buf);
3980         memset(dsp_buf, 0, sizeof(dsp_buf));
3981         size += snprintf(dsp_buf, 80,
3982                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
3983                  w2_2_st_x - h_pw_bp, w2_2_st_y - v_pw_bp,
3984                  vop_readl(vop_dev, WIN2_MST2));
3985         strcat(buf, dsp_buf);
3986         memset(dsp_buf, 0, sizeof(dsp_buf));
3987
3988         /*area 3*/
3989         size += snprintf(dsp_buf, 80,
3990                  "  area3: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
3991                  w2_3_state, format_w2_3, w2_3_dsp_x, w2_3_dsp_y);
3992         strcat(buf, dsp_buf);
3993         memset(dsp_buf, 0, sizeof(dsp_buf));
3994         size += snprintf(dsp_buf, 80,
3995                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
3996                  w2_3_st_x - h_pw_bp, w2_3_st_y - v_pw_bp,
3997                  vop_readl(vop_dev, WIN2_MST3));
3998         strcat(buf, dsp_buf);
3999         memset(dsp_buf, 0, sizeof(dsp_buf));
4000
4001         /*win3*/
4002         size += snprintf(dsp_buf, 80,
4003                  "win3:\n  state:%d\n",
4004                  w3_state);
4005         strcat(buf, dsp_buf);
4006         memset(dsp_buf, 0, sizeof(dsp_buf));
4007         /*area 0*/
4008         size += snprintf(dsp_buf, 80,
4009                  "  area0: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
4010                  w3_0_state, format_w3_0, w3_0_dsp_x, w3_0_dsp_y);
4011         strcat(buf, dsp_buf);
4012         memset(dsp_buf, 0, sizeof(dsp_buf));
4013         size += snprintf(dsp_buf, 80,
4014                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
4015                  w3_0_st_x - h_pw_bp, w3_0_st_y - v_pw_bp,
4016                  vop_readl(vop_dev, WIN3_MST0));
4017         strcat(buf, dsp_buf);
4018         memset(dsp_buf, 0, sizeof(dsp_buf));
4019
4020         /*area 1*/
4021         size += snprintf(dsp_buf, 80,
4022                  "  area1: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
4023                  w3_1_state, format_w3_1, w3_1_dsp_x, w3_1_dsp_y);
4024         strcat(buf, dsp_buf);
4025         memset(dsp_buf, 0, sizeof(dsp_buf));
4026         size += snprintf(dsp_buf, 80,
4027                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
4028                  w3_1_st_x - h_pw_bp, w3_1_st_y - v_pw_bp,
4029                  vop_readl(vop_dev, WIN3_MST1));
4030         strcat(buf, dsp_buf);
4031         memset(dsp_buf, 0, sizeof(dsp_buf));
4032
4033         /*area 2*/
4034         size += snprintf(dsp_buf, 80,
4035                  "  area2: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
4036                  w3_2_state, format_w3_2, w3_2_dsp_x, w3_2_dsp_y);
4037         strcat(buf, dsp_buf);
4038         memset(dsp_buf, 0, sizeof(dsp_buf));
4039         size += snprintf(dsp_buf, 80,
4040                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
4041                  w3_2_st_x - h_pw_bp, w3_2_st_y - v_pw_bp,
4042                  vop_readl(vop_dev, WIN3_MST2));
4043         strcat(buf, dsp_buf);
4044         memset(dsp_buf, 0, sizeof(dsp_buf));
4045
4046         /*area 3*/
4047         size += snprintf(dsp_buf, 80,
4048                  "  area3: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
4049                  w3_3_state, format_w3_3, w3_3_dsp_x, w3_3_dsp_y);
4050         strcat(buf, dsp_buf);
4051         memset(dsp_buf, 0, sizeof(dsp_buf));
4052         size += snprintf(dsp_buf, 80,
4053                  " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
4054                  w3_3_st_x - h_pw_bp, w3_3_st_y - v_pw_bp,
4055                  vop_readl(vop_dev, WIN3_MST3));
4056         strcat(buf, dsp_buf);
4057         memset(dsp_buf, 0, sizeof(dsp_buf));
4058
4059         return size;
4060 }
4061
4062 static int vop_fps_mgr(struct rk_lcdc_driver *dev_drv, int fps, bool set)
4063 {
4064         struct vop_device *vop_dev =
4065             container_of(dev_drv, struct vop_device, driver);
4066         struct rk_screen *screen = dev_drv->cur_screen;
4067         u64 ft = 0;
4068         u32 dotclk;
4069         int ret;
4070         u32 pixclock;
4071         u32 x_total, y_total;
4072
4073         if (set) {
4074                 if (fps == 0) {
4075                         dev_info(dev_drv->dev, "unsupport set fps=0\n");
4076                         return 0;
4077                 }
4078                 ft = div_u64(1000000000000llu, fps);
4079                 x_total =
4080                     screen->mode.upper_margin + screen->mode.lower_margin +
4081                     screen->mode.yres + screen->mode.vsync_len;
4082                 y_total =
4083                     screen->mode.left_margin + screen->mode.right_margin +
4084                     screen->mode.xres + screen->mode.hsync_len;
4085                 dev_drv->pixclock = div_u64(ft, x_total * y_total);
4086                 dotclk = div_u64(1000000000000llu, dev_drv->pixclock);
4087                 ret = clk_set_rate(vop_dev->dclk, dotclk);
4088         }
4089
4090         pixclock = div_u64(1000000000000llu, clk_get_rate(vop_dev->dclk));
4091         vop_dev->pixclock = pixclock;
4092         dev_drv->pixclock = vop_dev->pixclock;
4093         fps = rk_fb_calc_fps(screen, pixclock);
4094         screen->ft = 1000 / fps;        /*one frame time in ms */
4095
4096         if (set)
4097                 dev_info(dev_drv->dev, "%s:dclk:%lu,fps:%d\n", __func__,
4098                          clk_get_rate(vop_dev->dclk), fps);
4099
4100         return fps;
4101 }
4102
4103 static int vop_fb_win_remap(struct rk_lcdc_driver *dev_drv, u16 order)
4104 {
4105         mutex_lock(&dev_drv->fb_win_id_mutex);
4106         if (order == FB_DEFAULT_ORDER)
4107                 order = FB0_WIN0_FB1_WIN1_FB2_WIN2_FB3_WIN3_FB4_HWC;
4108         dev_drv->fb4_win_id = order / 10000;
4109         dev_drv->fb3_win_id = (order / 1000) % 10;
4110         dev_drv->fb2_win_id = (order / 100) % 10;
4111         dev_drv->fb1_win_id = (order / 10) % 10;
4112         dev_drv->fb0_win_id = order % 10;
4113         mutex_unlock(&dev_drv->fb_win_id_mutex);
4114
4115         return 0;
4116 }
4117
4118 static int vop_get_win_id(struct rk_lcdc_driver *dev_drv, const char *id)
4119 {
4120         int win_id = 0;
4121
4122         mutex_lock(&dev_drv->fb_win_id_mutex);
4123         if (!strcmp(id, "fb0") || !strcmp(id, "fb5"))
4124                 win_id = dev_drv->fb0_win_id;
4125         else if (!strcmp(id, "fb1") || !strcmp(id, "fb6"))
4126                 win_id = dev_drv->fb1_win_id;
4127         else if (!strcmp(id, "fb2") || !strcmp(id, "fb7"))
4128                 win_id = dev_drv->fb2_win_id;
4129         else if (!strcmp(id, "fb3") || !strcmp(id, "fb8"))
4130                 win_id = dev_drv->fb3_win_id;
4131         else if (!strcmp(id, "fb4") || !strcmp(id, "fb9"))
4132                 win_id = dev_drv->fb4_win_id;
4133         mutex_unlock(&dev_drv->fb_win_id_mutex);
4134
4135         return win_id;
4136 }
4137
4138 static int vop_config_done(struct rk_lcdc_driver *dev_drv)
4139 {
4140         struct vop_device *vop_dev =
4141             container_of(dev_drv, struct vop_device, driver);
4142         int i, fbdc_en = 0;
4143         u64 val;
4144         struct rk_lcdc_win *win = NULL;
4145
4146         spin_lock(&vop_dev->reg_lock);
4147         vop_post_cfg(dev_drv);
4148         vop_msk_reg(vop_dev, SYS_CTRL, V_VOP_STANDBY_EN(vop_dev->standby));
4149         for (i = 0; i < dev_drv->lcdc_win_num; i++) {
4150                 win = dev_drv->win[i];
4151                 vop_alpha_cfg(dev_drv, i);
4152                 fbdc_en |= win->area[0].fbdc_en;
4153                 vop_dev->atv_layer_cnt &= ~(1 << win->id);
4154                 vop_dev->atv_layer_cnt |= (win->state << win->id);
4155                 if ((win->state == 0) && (win->last_state == 1)) {
4156                         switch (win->id) {
4157                         case 0:
4158                                 val = V_WIN0_EN(0);
4159                                 vop_msk_reg(vop_dev, WIN0_CTRL0, val);
4160                                 break;
4161                         case 1:
4162                                 val = V_WIN1_EN(0);
4163                                 vop_msk_reg(vop_dev, WIN1_CTRL0, val);
4164                                 break;
4165                         case 2:
4166                                 val = V_WIN2_EN(0) | V_WIN2_MST0_EN(0) |
4167                                     V_WIN2_MST1_EN(0) |
4168                                     V_WIN2_MST2_EN(0) | V_WIN2_MST3_EN(0);
4169                                 vop_msk_reg(vop_dev, WIN2_CTRL0, val);
4170                                 break;
4171                         case 3:
4172                                 val = V_WIN3_EN(0) | V_WIN3_MST0_EN(0) |
4173                                     V_WIN3_MST1_EN(0) |
4174                                     V_WIN3_MST2_EN(0) | V_WIN3_MST3_EN(0);
4175                                 vop_msk_reg(vop_dev, WIN3_CTRL0, val);
4176                                 break;
4177                         case 4:
4178                                 val = V_HWC_EN(0);
4179                                 vop_msk_reg(vop_dev, HWC_CTRL0, val);
4180                                 break;
4181                         default:
4182                                 break;
4183                         }
4184                 }
4185                 win->last_state = win->state;
4186         }
4187         if (VOP_CHIP(vop_dev) == VOP_RK3399) {
4188                 val = V_VOP_FBDC_EN(fbdc_en);
4189                 vop_msk_reg(vop_dev, AFBCD0_CTRL, val);
4190         }
4191         vop_cfg_done(vop_dev);
4192         spin_unlock(&vop_dev->reg_lock);
4193         return 0;
4194 }
4195
4196 static int vop_dpi_open(struct rk_lcdc_driver *dev_drv, bool open)
4197 {
4198         struct vop_device *vop_dev =
4199             container_of(dev_drv, struct vop_device, driver);
4200         spin_lock(&vop_dev->reg_lock);
4201         vop_msk_reg(vop_dev, SYS_CTRL, V_DIRECT_PATH_EN(open));
4202         vop_cfg_done(vop_dev);
4203         spin_unlock(&vop_dev->reg_lock);
4204         return 0;
4205 }
4206
4207 static int vop_dpi_win_sel(struct rk_lcdc_driver *dev_drv, int win_id)
4208 {
4209         struct vop_device *vop_dev = container_of(dev_drv,
4210                                                     struct vop_device, driver);
4211         spin_lock(&vop_dev->reg_lock);
4212         vop_msk_reg(vop_dev, SYS_CTRL, V_DIRECT_PATH_LAYER_SEL(win_id));
4213         vop_cfg_done(vop_dev);
4214         spin_unlock(&vop_dev->reg_lock);
4215         return 0;
4216 }
4217
4218 static int vop_dpi_status(struct rk_lcdc_driver *dev_drv)
4219 {
4220         struct vop_device *vop_dev =
4221             container_of(dev_drv, struct vop_device, driver);
4222         int ovl;
4223
4224         spin_lock(&vop_dev->reg_lock);
4225         ovl = vop_read_bit(vop_dev, SYS_CTRL, V_DIRECT_PATH_EN(0));
4226         spin_unlock(&vop_dev->reg_lock);
4227         return ovl;
4228 }
4229
4230 static int vop_set_irq_to_cpu(struct rk_lcdc_driver *dev_drv, int enable)
4231 {
4232         struct vop_device *vop_dev =
4233                         container_of(dev_drv, struct vop_device, driver);
4234         if (enable)
4235                 enable_irq(vop_dev->irq);
4236         else
4237                 disable_irq_nosync(vop_dev->irq);
4238         return 0;
4239 }
4240
4241 int vop_poll_vblank(struct rk_lcdc_driver *dev_drv)
4242 {
4243         struct vop_device *vop_dev =
4244             container_of(dev_drv, struct vop_device, driver);
4245         u32 int_reg;
4246         int ret;
4247
4248         if (vop_dev->clk_on && (!dev_drv->suspend_flag)) {
4249                 int_reg = vop_readl(vop_dev, INTR_STATUS0);
4250                 if (int_reg & INTR_LINE_FLAG0) {
4251                         vop_dev->driver.frame_time.last_framedone_t =
4252                             vop_dev->driver.frame_time.framedone_t;
4253                         vop_dev->driver.frame_time.framedone_t = cpu_clock(0);
4254                         vop_mask_writel(vop_dev, INTR_CLEAR0, INTR_LINE_FLAG0,
4255                                         INTR_LINE_FLAG0);
4256                         ret = RK_LF_STATUS_FC;
4257                 } else {
4258                         ret = RK_LF_STATUS_FR;
4259                 }
4260         } else {
4261                 ret = RK_LF_STATUS_NC;
4262         }
4263
4264         return ret;
4265 }
4266
4267 static int vop_get_dsp_addr(struct rk_lcdc_driver *dev_drv,
4268                             unsigned int dsp_addr[][4])
4269 {
4270         struct vop_device *vop_dev =
4271             container_of(dev_drv, struct vop_device, driver);
4272         spin_lock(&vop_dev->reg_lock);
4273         if (vop_dev->clk_on) {
4274                 dsp_addr[0][0] = vop_readl(vop_dev, WIN0_YRGB_MST);
4275                 dsp_addr[1][0] = vop_readl(vop_dev, WIN1_YRGB_MST);
4276                 dsp_addr[2][0] = vop_readl(vop_dev, WIN2_MST0);
4277                 dsp_addr[2][1] = vop_readl(vop_dev, WIN2_MST1);
4278                 dsp_addr[2][2] = vop_readl(vop_dev, WIN2_MST2);
4279                 dsp_addr[2][3] = vop_readl(vop_dev, WIN2_MST3);
4280                 dsp_addr[3][0] = vop_readl(vop_dev, WIN3_MST0);
4281                 dsp_addr[3][1] = vop_readl(vop_dev, WIN3_MST1);
4282                 dsp_addr[3][2] = vop_readl(vop_dev, WIN3_MST2);
4283                 dsp_addr[3][3] = vop_readl(vop_dev, WIN3_MST3);
4284                 dsp_addr[4][0] = vop_readl(vop_dev, HWC_MST);
4285         }
4286         spin_unlock(&vop_dev->reg_lock);
4287         return 0;
4288 }
4289
4290
4291 int vop_update_pwm(int bl_pwm_period, int bl_pwm_duty)
4292 {
4293         /*
4294          * TODO:
4295          * pwm_period_hpr = bl_pwm_period;
4296          * pwm_duty_lpr = bl_pwm_duty;
4297          * pr_info("bl_pwm_period_hpr = 0x%x, bl_pwm_duty_lpr = 0x%x\n",
4298          * bl_pwm_period, bl_pwm_duty);
4299          */
4300
4301         return 0;
4302 }
4303
4304 /*
4305  *  a:[-30~0]:
4306  *    sin_hue = sin(a)*256 +0x100;
4307  *    cos_hue = cos(a)*256;
4308  *  a:[0~30]
4309  *    sin_hue = sin(a)*256;
4310  *    cos_hue = cos(a)*256;
4311  */
4312 static int vop_get_bcsh_hue(struct rk_lcdc_driver *dev_drv, bcsh_hue_mode mode)
4313 {
4314         struct vop_device *vop_dev =
4315             container_of(dev_drv, struct vop_device, driver);
4316         u32 val = 0;
4317
4318         spin_lock(&vop_dev->reg_lock);
4319         if (vop_dev->clk_on) {
4320                 val = vop_readl(vop_dev, BCSH_H);
4321                 switch (mode) {
4322                 case H_SIN:
4323                         val &= MASK(SIN_HUE);
4324                         break;
4325                 case H_COS:
4326                         val &= MASK(COS_HUE);
4327                         val >>= 16;
4328                         break;
4329                 default:
4330                         break;
4331                 }
4332         }
4333         spin_unlock(&vop_dev->reg_lock);
4334
4335         return val;
4336 }
4337
4338 static int vop_set_dsp_cabc(struct rk_lcdc_driver *dev_drv, int mode,
4339                             int calc, int up, int down, int global)
4340 {
4341         struct vop_device *vop_dev =
4342                         container_of(dev_drv, struct vop_device, driver);
4343         struct rk_screen *screen = dev_drv->cur_screen;
4344         u32 total_pixel, calc_pixel, stage_up, stage_down;
4345         u32 pixel_num, global_dn;
4346
4347         if (!vop_dev->cabc_lut_addr_base) {
4348                 pr_err("vop chip[%d] not supoort cabc\n", VOP_CHIP(vop_dev));
4349                 return 0;
4350         }
4351
4352         if (!screen->cabc_lut) {
4353                 pr_err("screen cabc lut not config, so not open cabc\n");
4354                 return 0;
4355         }
4356
4357         dev_drv->cabc_mode = mode;
4358         if (!dev_drv->cabc_mode) {
4359                 spin_lock(&vop_dev->reg_lock);
4360                 if (vop_dev->clk_on) {
4361                         vop_msk_reg(vop_dev, CABC_CTRL0,
4362                                     V_CABC_EN(0) | V_CABC_HANDLE_EN(0));
4363                         vop_cfg_done(vop_dev);
4364                 }
4365                 pr_info("mode = 0, close cabc\n");
4366                 spin_unlock(&vop_dev->reg_lock);
4367                 return 0;
4368         }
4369
4370         total_pixel = screen->mode.xres * screen->mode.yres;
4371         pixel_num = 1000 - calc;
4372         calc_pixel = (total_pixel * pixel_num) / 1000;
4373         stage_up = up;
4374         stage_down = down;
4375         global_dn = global;
4376         pr_info("enable cabc:mode=%d, calc=%d, up=%d, down=%d, global=%d\n",
4377                 mode, calc, stage_up, stage_down, global_dn);
4378
4379         spin_lock(&vop_dev->reg_lock);
4380         if (vop_dev->clk_on) {
4381                 u64 val = 0;
4382
4383                 val = V_CABC_EN(1) | V_CABC_HANDLE_EN(1) |
4384                         V_PWM_CONFIG_MODE(STAGE_BY_STAGE) |
4385                         V_CABC_CALC_PIXEL_NUM(calc_pixel);
4386                 vop_msk_reg(vop_dev, CABC_CTRL0, val);
4387
4388                 val = V_CABC_LUT_EN(1) | V_CABC_TOTAL_NUM(total_pixel);
4389                 vop_msk_reg(vop_dev, CABC_CTRL1, val);
4390
4391                 val = V_CABC_STAGE_DOWN(stage_down) |
4392                         V_CABC_STAGE_UP(stage_up) |
4393                         V_CABC_STAGE_UP_MODE(0) | V_MAX_SCALE_CFG_VALUE(1) |
4394                         V_MAX_SCALE_CFG_ENABLE(0);
4395                 vop_msk_reg(vop_dev, CABC_CTRL2, val);
4396
4397                 val = V_CABC_GLOBAL_DN(global_dn) |
4398                         V_CABC_GLOBAL_DN_LIMIT_EN(1);
4399                 vop_msk_reg(vop_dev, CABC_CTRL3, val);
4400                 vop_cfg_done(vop_dev);
4401         }
4402         spin_unlock(&vop_dev->reg_lock);
4403
4404         return 0;
4405 }
4406
4407 static int vop_set_bcsh_hue(struct rk_lcdc_driver *dev_drv,
4408                             int sin_hue, int cos_hue)
4409 {
4410         struct vop_device *vop_dev =
4411             container_of(dev_drv, struct vop_device, driver);
4412         u64 val;
4413
4414         spin_lock(&vop_dev->reg_lock);
4415         if (vop_dev->clk_on) {
4416                 val = V_SIN_HUE(sin_hue) | V_COS_HUE(cos_hue);
4417                 vop_msk_reg(vop_dev, BCSH_H, val);
4418                 vop_cfg_done(vop_dev);
4419         }
4420         spin_unlock(&vop_dev->reg_lock);
4421
4422         return 0;
4423 }
4424
4425 static int vop_set_bcsh_bcs(struct rk_lcdc_driver *dev_drv,
4426                             bcsh_bcs_mode mode, int value)
4427 {
4428         struct vop_device *vop_dev =
4429             container_of(dev_drv, struct vop_device, driver);
4430         u64 val = 0;
4431
4432         spin_lock(&vop_dev->reg_lock);
4433         if (vop_dev->clk_on) {
4434                 switch (mode) {
4435                 case BRIGHTNESS:
4436                         /*from 0 to 255,typical is 128 */
4437                         if (value < 0x80)
4438                                 value += 0x80;
4439                         else if (value >= 0x80)
4440                                 value = value - 0x80;
4441                         val = V_BRIGHTNESS(value);
4442                         break;
4443                 case CONTRAST:
4444                         /*from 0 to 510,typical is 256 */
4445                         val = V_CONTRAST(value);
4446                         break;
4447                 case SAT_CON:
4448                         /*from 0 to 1015,typical is 256 */
4449                         val = V_SAT_CON(value);
4450                         break;
4451                 default:
4452                         break;
4453                 }
4454                 vop_msk_reg(vop_dev, BCSH_BCS, val);
4455                 vop_cfg_done(vop_dev);
4456         }
4457         spin_unlock(&vop_dev->reg_lock);
4458
4459         return val;
4460 }
4461
4462 static int vop_get_bcsh_bcs(struct rk_lcdc_driver *dev_drv, bcsh_bcs_mode mode)
4463 {
4464         struct vop_device *vop_dev =
4465             container_of(dev_drv, struct vop_device, driver);
4466         u64 val = 0;
4467
4468         spin_lock(&vop_dev->reg_lock);
4469         if (vop_dev->clk_on) {
4470                 val = vop_readl(vop_dev, BCSH_BCS);
4471                 switch (mode) {
4472                 case BRIGHTNESS:
4473                         val &= MASK(BRIGHTNESS);
4474                         if (val > 0x80)
4475                                 val -= 0x80;
4476                         else
4477                                 val += 0x80;
4478                         break;
4479                 case CONTRAST:
4480                         val &= MASK(CONTRAST);
4481                         val >>= 8;
4482                         break;
4483                 case SAT_CON:
4484                         val &= MASK(SAT_CON);
4485                         val >>= 20;
4486                         break;
4487                 default:
4488                         break;
4489                 }
4490         }
4491         spin_unlock(&vop_dev->reg_lock);
4492         return val;
4493 }
4494
4495 static int vop_open_bcsh(struct rk_lcdc_driver *dev_drv, bool open)
4496 {
4497         struct vop_device *vop_dev =
4498             container_of(dev_drv, struct vop_device, driver);
4499
4500         spin_lock(&vop_dev->reg_lock);
4501         if (vop_dev->clk_on) {
4502                 if (open) {
4503                         vop_writel(vop_dev, BCSH_COLOR_BAR, 0x1);
4504                         vop_writel(vop_dev, BCSH_BCS, 0xd0010000);
4505                         vop_writel(vop_dev, BCSH_H, 0x01000000);
4506                         dev_drv->bcsh.enable = 1;
4507                 } else {
4508                         vop_msk_reg(vop_dev, BCSH_COLOR_BAR, V_BCSH_EN(0));
4509                         dev_drv->bcsh.enable = 0;
4510                 }
4511                 vop_bcsh_path_sel(dev_drv);
4512                 vop_cfg_done(vop_dev);
4513         }
4514         spin_unlock(&vop_dev->reg_lock);
4515
4516         return 0;
4517 }
4518
4519 static int vop_set_bcsh(struct rk_lcdc_driver *dev_drv, bool enable)
4520 {
4521         if (!enable || !dev_drv->bcsh.enable) {
4522                 vop_open_bcsh(dev_drv, false);
4523                 return 0;
4524         }
4525
4526         if (dev_drv->bcsh.brightness <= 255 ||
4527             dev_drv->bcsh.contrast <= 510 ||
4528             dev_drv->bcsh.sat_con <= 1015 ||
4529             (dev_drv->bcsh.sin_hue <= 511 && dev_drv->bcsh.cos_hue <= 511)) {
4530                 vop_open_bcsh(dev_drv, true);
4531                 if (dev_drv->bcsh.brightness <= 255)
4532                         vop_set_bcsh_bcs(dev_drv, BRIGHTNESS,
4533                                          dev_drv->bcsh.brightness);
4534                 if (dev_drv->bcsh.contrast <= 510)
4535                         vop_set_bcsh_bcs(dev_drv, CONTRAST,
4536                                          dev_drv->bcsh.contrast);
4537                 if (dev_drv->bcsh.sat_con <= 1015)
4538                         vop_set_bcsh_bcs(dev_drv, SAT_CON,
4539                                          dev_drv->bcsh.sat_con);
4540                 if (dev_drv->bcsh.sin_hue <= 511 &&
4541                     dev_drv->bcsh.cos_hue <= 511)
4542                         vop_set_bcsh_hue(dev_drv, dev_drv->bcsh.sin_hue,
4543                                          dev_drv->bcsh.cos_hue);
4544         }
4545
4546         return 0;
4547 }
4548
4549 static int __maybe_unused
4550 vop_dsp_black(struct rk_lcdc_driver *dev_drv, int enable)
4551 {
4552         struct vop_device *vop_dev =
4553             container_of(dev_drv, struct vop_device, driver);
4554
4555         if (enable) {
4556                 spin_lock(&vop_dev->reg_lock);
4557                 if (likely(vop_dev->clk_on)) {
4558                         vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_BLACK_EN(1));
4559                         vop_cfg_done(vop_dev);
4560                 }
4561                 spin_unlock(&vop_dev->reg_lock);
4562         } else {
4563                 spin_lock(&vop_dev->reg_lock);
4564                 if (likely(vop_dev->clk_on)) {
4565                         vop_msk_reg(vop_dev, DSP_CTRL0, V_DSP_BLACK_EN(0));
4566
4567                         vop_cfg_done(vop_dev);
4568                 }
4569                 spin_unlock(&vop_dev->reg_lock);
4570         }
4571
4572         return 0;
4573 }
4574
4575 static int vop_backlight_close(struct rk_lcdc_driver *dev_drv, int enable)
4576 {
4577         struct vop_device *vop_dev =
4578             container_of(dev_drv, struct vop_device, driver);
4579
4580         if (unlikely(!vop_dev->clk_on)) {
4581                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
4582                 return 0;
4583         }
4584         vop_get_backlight_device(dev_drv);
4585
4586         if (enable) {
4587                 /* close the backlight */
4588                 if (vop_dev->backlight) {
4589                         vop_dev->backlight->props.power = FB_BLANK_POWERDOWN;
4590                         backlight_update_status(vop_dev->backlight);
4591                 }
4592                 if (dev_drv->trsm_ops && dev_drv->trsm_ops->disable)
4593                         dev_drv->trsm_ops->disable();
4594         } else {
4595                 if (dev_drv->trsm_ops && dev_drv->trsm_ops->enable)
4596                         dev_drv->trsm_ops->enable();
4597                 msleep(100);
4598                 /* open the backlight */
4599                 if (vop_dev->backlight) {
4600                         vop_dev->backlight->props.power = FB_BLANK_UNBLANK;
4601                         backlight_update_status(vop_dev->backlight);
4602                 }
4603         }
4604
4605         return 0;
4606 }
4607
4608 static int vop_set_overscan(struct rk_lcdc_driver *dev_drv,
4609                             struct overscan *overscan)
4610 {
4611         struct vop_device *vop_dev =
4612             container_of(dev_drv, struct vop_device, driver);
4613
4614         if (unlikely(!vop_dev->clk_on)) {
4615                 pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
4616                 return 0;
4617         }
4618         /*vop_post_cfg(dev_drv);*/
4619
4620         return 0;
4621 }
4622
4623 static struct rk_lcdc_drv_ops lcdc_drv_ops = {
4624         .open = vop_open,
4625         .win_direct_en = vop_win_direct_en,
4626         .load_screen = vop_load_screen,
4627         .get_dspbuf_info = vop_get_dspbuf_info,
4628         .post_dspbuf = vop_post_dspbuf,
4629         .set_par = vop_set_par,
4630         .pan_display = vop_pan_display,
4631         .set_wb = vop_set_writeback,
4632         .direct_set_addr = vop_direct_set_win_addr,
4633         /*.lcdc_reg_update = vop_reg_update,*/
4634         .blank = vop_blank,
4635         .ioctl = vop_ioctl,
4636         .suspend = vop_early_suspend,
4637         .resume = vop_early_resume,
4638         .get_win_state = vop_get_win_state,
4639         .area_support_num = vop_get_area_num,
4640         .ovl_mgr = vop_ovl_mgr,
4641         .get_disp_info = vop_get_disp_info,
4642         .fps_mgr = vop_fps_mgr,
4643         .fb_get_win_id = vop_get_win_id,
4644         .fb_win_remap = vop_fb_win_remap,
4645         .poll_vblank = vop_poll_vblank,
4646         .dpi_open = vop_dpi_open,
4647         .dpi_win_sel = vop_dpi_win_sel,
4648         .dpi_status = vop_dpi_status,
4649         .get_dsp_addr = vop_get_dsp_addr,
4650         .set_dsp_lut = vop_set_lut,
4651         .set_cabc_lut = vop_set_cabc,
4652         .set_dsp_cabc = vop_set_dsp_cabc,
4653         .set_dsp_bcsh_hue = vop_set_bcsh_hue,
4654         .set_dsp_bcsh_bcs = vop_set_bcsh_bcs,
4655         .get_dsp_bcsh_hue = vop_get_bcsh_hue,
4656         .get_dsp_bcsh_bcs = vop_get_bcsh_bcs,
4657         .open_bcsh = vop_open_bcsh,
4658         .dump_reg = vop_reg_dump,
4659         .cfg_done = vop_config_done,
4660         .set_irq_to_cpu = vop_set_irq_to_cpu,
4661         /*.dsp_black = vop_dsp_black,*/
4662         .backlight_close = vop_backlight_close,
4663         .mmu_en    = vop_mmu_en,
4664         .set_overscan   = vop_set_overscan,
4665 };
4666
4667 static irqreturn_t vop_isr(int irq, void *dev_id)
4668 {
4669         struct vop_device *vop_dev = (struct vop_device *)dev_id;
4670         ktime_t timestamp = ktime_get();
4671         u32 intr_status;
4672         unsigned long flags;
4673
4674         spin_lock_irqsave(&vop_dev->irq_lock, flags);
4675
4676         intr_status = vop_readl(vop_dev, INTR_STATUS0);
4677         vop_mask_writel(vop_dev, INTR_CLEAR0, INTR_MASK, intr_status);
4678
4679         spin_unlock_irqrestore(&vop_dev->irq_lock, flags);
4680         /* This is expected for vop iommu irqs, since the irq is shared */
4681         if (!intr_status)
4682                 return IRQ_NONE;
4683
4684         if (intr_status & INTR_FS) {
4685                 timestamp = ktime_get();
4686                 if (vop_dev->driver.wb_data.state) {
4687                         u32 wb_status;
4688
4689                         spin_lock_irqsave(&vop_dev->irq_lock, flags);
4690                         wb_status = vop_read_bit(vop_dev, WB_CTRL0, V_WB_EN(0));
4691
4692                         if (wb_status)
4693                                 vop_clr_bit(vop_dev, WB_CTRL0, V_WB_EN(0));
4694
4695                         vop_cfg_done(vop_dev);
4696                         vop_dev->driver.wb_data.state = 0;
4697                         spin_unlock_irqrestore(&vop_dev->irq_lock, flags);
4698                 }
4699                 vop_dev->driver.vsync_info.timestamp = timestamp;
4700                 wake_up_interruptible_all(&vop_dev->driver.vsync_info.wait);
4701                 intr_status &= ~INTR_FS;
4702         }
4703
4704         if (intr_status & INTR_LINE_FLAG0)
4705                 intr_status &= ~INTR_LINE_FLAG0;
4706
4707         if (intr_status & INTR_LINE_FLAG1)
4708                 intr_status &= ~INTR_LINE_FLAG1;
4709
4710         if (intr_status & INTR_FS_NEW)
4711                 intr_status &= ~INTR_FS_NEW;
4712
4713         if (intr_status & INTR_BUS_ERROR) {
4714                 intr_status &= ~INTR_BUS_ERROR;
4715                 dev_warn_ratelimited(vop_dev->dev, "bus error!");
4716         }
4717
4718         if (intr_status & INTR_WIN0_EMPTY) {
4719                 intr_status &= ~INTR_WIN0_EMPTY;
4720                 dev_warn_ratelimited(vop_dev->dev, "intr win0 empty!");
4721         }
4722
4723         if (intr_status & INTR_WIN1_EMPTY) {
4724                 intr_status &= ~INTR_WIN1_EMPTY;
4725                 dev_warn_ratelimited(vop_dev->dev, "intr win1 empty!");
4726         }
4727
4728         if (intr_status & INTR_HWC_EMPTY) {
4729                 intr_status &= ~INTR_HWC_EMPTY;
4730                 dev_warn_ratelimited(vop_dev->dev, "intr hwc empty!");
4731         }
4732
4733         if (intr_status & INTR_POST_BUF_EMPTY) {
4734                 intr_status &= ~INTR_POST_BUF_EMPTY;
4735                 dev_warn_ratelimited(vop_dev->dev, "intr post buf empty!");
4736         }
4737
4738         if (intr_status)
4739                 dev_err(vop_dev->dev, "Unknown VOP IRQs: %#02x\n", intr_status);
4740
4741         return IRQ_HANDLED;
4742 }
4743
4744 #if defined(CONFIG_PM)
4745 static int vop_suspend(struct platform_device *pdev, pm_message_t state)
4746 {
4747         return 0;
4748 }
4749
4750 static int vop_resume(struct platform_device *pdev)
4751 {
4752         return 0;
4753 }
4754 #else
4755 #define vop_suspend NULL
4756 #define vop_resume  NULL
4757 #endif
4758
4759 static int vop_parse_dt(struct vop_device *vop_dev)
4760 {
4761         struct device_node *np = vop_dev->dev->of_node;
4762         struct rk_lcdc_driver *dev_drv = &vop_dev->driver;
4763         int val;
4764
4765         if (of_property_read_u32(np, "rockchip,prop", &val))
4766                 vop_dev->prop = PRMRY;  /*default set it as primary */
4767         else
4768                 vop_dev->prop = val;
4769
4770         if (of_property_read_u32(np, "rockchip,mirror", &val))
4771                 dev_drv->rotate_mode = NO_MIRROR;
4772         else
4773                 dev_drv->rotate_mode = val;
4774
4775         if (of_property_read_u32(np, "rockchip,pwr18", &val))
4776                 /*default set it as 3.xv power supply */
4777                 vop_dev->pwr18 = false;
4778         else
4779                 vop_dev->pwr18 = (val ? true : false);
4780
4781         if (of_property_read_u32(np, "rockchip,fb-win-map", &val))
4782                 dev_drv->fb_win_map = FB_DEFAULT_ORDER;
4783         else
4784                 dev_drv->fb_win_map = val;
4785
4786         if (of_property_read_u32(np, "rockchip,bcsh-en", &val))
4787                 dev_drv->bcsh.enable = false;
4788         else
4789                 dev_drv->bcsh.enable = (val ? true : false);
4790
4791         if (of_property_read_u32(np, "rockchip,brightness", &val))
4792                 dev_drv->bcsh.brightness = 0xffff;
4793         else
4794                 dev_drv->bcsh.brightness = val;
4795
4796         if (of_property_read_u32(np, "rockchip,contrast", &val))
4797                 dev_drv->bcsh.contrast = 0xffff;
4798         else
4799                 dev_drv->bcsh.contrast = val;
4800
4801         if (of_property_read_u32(np, "rockchip,sat-con", &val))
4802                 dev_drv->bcsh.sat_con = 0xffff;
4803         else
4804                 dev_drv->bcsh.sat_con = val;
4805
4806         if (of_property_read_u32(np, "rockchip,hue", &val)) {
4807                 dev_drv->bcsh.sin_hue = 0xffff;
4808                 dev_drv->bcsh.cos_hue = 0xffff;
4809         } else {
4810                 dev_drv->bcsh.sin_hue = val & 0xff;
4811                 dev_drv->bcsh.cos_hue = (val >> 8) & 0xff;
4812         }
4813
4814         if (of_property_read_u32(np, "rockchip,iommu-enabled", &val))
4815                 dev_drv->iommu_enabled = 0;
4816         else
4817                 dev_drv->iommu_enabled = val;
4818         return 0;
4819 }
4820
4821 static int vop_probe(struct platform_device *pdev)
4822 {
4823         struct vop_device *vop_dev = NULL;
4824         struct rk_lcdc_driver *dev_drv;
4825         const struct of_device_id *of_id;
4826         struct device *dev = &pdev->dev;
4827         struct resource *res;
4828         struct device_node *np = pdev->dev.of_node;
4829         int prop;
4830         int ret = 0;
4831
4832         /* if the primary lcdc has not registered ,the extend
4833          * lcdc register later
4834          */
4835         of_property_read_u32(np, "rockchip,prop", &prop);
4836         if (prop == EXTEND) {
4837                 if (!is_prmry_rk_lcdc_registered())
4838                         return -EPROBE_DEFER;
4839         }
4840         vop_dev = devm_kzalloc(dev, sizeof(struct vop_device), GFP_KERNEL);
4841         if (!vop_dev)
4842                 return -ENOMEM;
4843         of_id = of_match_device(vop_dt_ids, dev);
4844         vop_dev->data = of_id->data;
4845         if (VOP_CHIP(vop_dev) != VOP_RK322X && VOP_CHIP(vop_dev) != VOP_RK3399)
4846                 return -ENODEV;
4847         platform_set_drvdata(pdev, vop_dev);
4848         vop_dev->dev = dev;
4849         vop_parse_dt(vop_dev);
4850 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
4851         /* enable power domain */
4852         pm_runtime_enable(dev);
4853 #endif
4854         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
4855         vop_dev->reg_phy_base = res->start;
4856         vop_dev->len = resource_size(res);
4857         vop_dev->regs = devm_ioremap(&pdev->dev, res->start,
4858                                      resource_size(res));
4859         if (IS_ERR(vop_dev->regs))
4860                 return PTR_ERR(vop_dev->regs);
4861
4862         dev_info(dev, "vop_dev->regs=0x%lx\n", (long)vop_dev->regs);
4863
4864         vop_dev->regsbak = devm_kzalloc(dev, vop_dev->len, GFP_KERNEL);
4865         if (IS_ERR(vop_dev->regsbak))
4866                 return PTR_ERR(vop_dev->regsbak);
4867         if (VOP_CHIP(vop_dev) == VOP_RK3399) {
4868                 vop_dev->dsp_lut_addr_base = vop_dev->regs + GAMMA_LUT_ADDR;
4869                 vop_dev->cabc_lut_addr_base = vop_dev->regs +
4870                                                 CABC_GAMMA_LUT_ADDR;
4871         }
4872         vop_dev->grf_base =
4873                 syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
4874         if (IS_ERR(vop_dev->grf_base)) {
4875                 dev_err(&pdev->dev, "can't find lcdc grf property\n");
4876                 vop_dev->grf_base = NULL;
4877         }
4878
4879         vop_dev->id = vop_get_id(vop_dev, vop_dev->reg_phy_base);
4880         dev_set_name(vop_dev->dev, "vop%d", vop_dev->id);
4881         dev_drv = &vop_dev->driver;
4882         dev_drv->dev = dev;
4883         dev_drv->prop = prop;
4884         dev_drv->id = vop_dev->id;
4885         dev_drv->ops = &lcdc_drv_ops;
4886         dev_drv->lcdc_win_num = vop_dev->data->n_wins;
4887         dev_drv->reserved_fb = 0;
4888         spin_lock_init(&vop_dev->reg_lock);
4889         spin_lock_init(&vop_dev->irq_lock);
4890         vop_dev->irq = platform_get_irq(pdev, 0);
4891         if (vop_dev->irq < 0) {
4892                 dev_err(&pdev->dev, "cannot find IRQ for lcdc%d\n",
4893                         vop_dev->id);
4894                 return -ENXIO;
4895         }
4896
4897         ret = devm_request_irq(dev, vop_dev->irq, vop_isr,
4898                                IRQF_SHARED, dev_name(dev), vop_dev);
4899         if (ret) {
4900                 dev_err(&pdev->dev, "cannot requeset irq %d - err %d\n",
4901                         vop_dev->irq, ret);
4902                 return ret;
4903         }
4904         if (dev_drv->iommu_enabled) {
4905                 if (VOP_CHIP(vop_dev) == VOP_RK322X) {
4906                         strcpy(dev_drv->mmu_dts_name,
4907                                VOP_IOMMU_COMPATIBLE_NAME);
4908                 } else {
4909                         if (vop_dev->id == 0)
4910                                 strcpy(dev_drv->mmu_dts_name,
4911                                        VOPB_IOMMU_COMPATIBLE_NAME);
4912                         else
4913                                 strcpy(dev_drv->mmu_dts_name,
4914                                        VOPL_IOMMU_COMPATIBLE_NAME);
4915                 }
4916         }
4917         if (VOP_CHIP(vop_dev) == VOP_RK3399)
4918                 dev_drv->property.feature |= SUPPORT_WRITE_BACK | SUPPORT_AFBDC;
4919         dev_drv->property.feature |= SUPPORT_VOP_IDENTIFY |
4920                                         SUPPORT_YUV420_OUTPUT;
4921         dev_drv->property.max_output_x = 4096;
4922         dev_drv->property.max_output_y = 2160;
4923
4924         if ((VOP_CHIP(vop_dev) == VOP_RK3399) && (vop_dev->id == 1)) {
4925                 vop_dev->data->win[1].property.feature &= ~SUPPORT_HW_EXIST;
4926                 vop_dev->data->win[3].property.feature &= ~SUPPORT_HW_EXIST;
4927         }
4928
4929         ret = rk_fb_register(dev_drv, vop_dev->data->win, vop_dev->id);
4930         if (ret < 0) {
4931                 dev_err(dev, "register fb for lcdc%d failed!\n", vop_dev->id);
4932                 return ret;
4933         }
4934         vop_dev->screen = dev_drv->screen0;
4935         dev_info(dev, "lcdc%d probe ok, iommu %s\n",
4936                  vop_dev->id, dev_drv->iommu_enabled ? "enabled" : "disabled");
4937
4938         return 0;
4939 }
4940
4941 static int vop_remove(struct platform_device *pdev)
4942 {
4943         return 0;
4944 }
4945
4946 static void vop_shutdown(struct platform_device *pdev)
4947 {
4948         struct vop_device *vop_dev = platform_get_drvdata(pdev);
4949         struct rk_lcdc_driver *dev_drv = &vop_dev->driver;
4950
4951         dev_drv->suspend_flag = 1;
4952         /* ensure suspend_flag take effect on multi process */
4953         smp_wmb();
4954         flush_kthread_worker(&dev_drv->update_regs_worker);
4955         kthread_stop(dev_drv->update_regs_thread);
4956         vop_deint(vop_dev);
4957
4958         vop_clk_disable(vop_dev);
4959 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
4960         pm_runtime_disable(vop_dev->dev);
4961 #endif
4962         rk_disp_pwr_disable(dev_drv);
4963 }
4964
4965 static struct platform_driver vop_driver = {
4966         .probe = vop_probe,
4967         .remove = vop_remove,
4968         .driver = {
4969                    .name = "rk322x-lcdc",
4970                    .owner = THIS_MODULE,
4971                    .of_match_table = of_match_ptr(vop_dt_ids),
4972                    },
4973         .suspend = vop_suspend,
4974         .resume = vop_resume,
4975         .shutdown = vop_shutdown,
4976 };
4977
4978 static int __init vop_module_init(void)
4979 {
4980         return platform_driver_register(&vop_driver);
4981 }
4982
4983 static void __exit vop_module_exit(void)
4984 {
4985         platform_driver_unregister(&vop_driver);
4986 }
4987
4988 fs_initcall(vop_module_init);
4989 module_exit(vop_module_exit);