drivers/video/rockchip/lcdc/rk3066b_lcdc.c

   1 /*
   2  * drivers/video/rockchip/chips/rk3066b_lcdc.c
   3  *
   4  * Copyright (C) 2012 ROCKCHIP, Inc.
   5  *Author:yzq<yzq@rock-chips.com>
   6  *      yxj<yxj@rock-chips.com>
   7  *This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/errno.h>
  21 #include <linux/string.h>
  22 #include <linux/mm.h>
  23 #include <linux/slab.h>
  24 #include <linux/device.h>
  25 #include <linux/delay.h>
  26 #include <linux/init.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/clk.h>
  30 #include <linux/earlysuspend.h>
  31 #include <asm/div64.h>
  32 #include <asm/uaccess.h>
  33 #include <mach/iomux.h>
  34
  35 #include "rk3066b_lcdc.h"
  36
  37
  38
  39
  40
  41
  42 static int dbg_thresd = 0;
  43 module_param(dbg_thresd, int, S_IRUGO|S_IWUSR);
  44 #define DBG(level,x...) do { if(unlikely(dbg_thresd >= level)) printk(KERN_INFO x); } while (0)
  45
  46
  47 static int  rk3066b_lcdc_clk_enable(struct rk3066b_lcdc_device *lcdc_dev)
  48 {
  49
  50         clk_enable(lcdc_dev->hclk);
  51         clk_enable(lcdc_dev->dclk);
  52         clk_enable(lcdc_dev->aclk);
  53         clk_enable(lcdc_dev->pd);
  54
  55         spin_lock(&lcdc_dev->reg_lock);
  56         lcdc_dev->clk_on = 1;
  57         spin_unlock(&lcdc_dev->reg_lock);
  58         printk("rk3066b lcdc%d clk enable...\n",lcdc_dev->id);
  59
  60         return 0;
  61 }
  62
  63 static int rk3066b_lcdc_clk_disable(struct rk3066b_lcdc_device *lcdc_dev)
  64 {
  65         spin_lock(&lcdc_dev->reg_lock);
  66         lcdc_dev->clk_on = 0;
  67         spin_unlock(&lcdc_dev->reg_lock);
  68         mdelay(25);
  69         clk_disable(lcdc_dev->dclk);
  70         clk_disable(lcdc_dev->hclk);
  71         clk_disable(lcdc_dev->aclk);
  72         clk_disable(lcdc_dev->pd);
  73         printk("rk3066b lcdc%d clk disable...\n",lcdc_dev->id);
  74
  75         return 0;
  76 }
  77
  78 static int rk3066b_lcdc_reg_resume(struct rk3066b_lcdc_device *lcdc_dev)
  79 {
  80         memcpy((u8*)lcdc_dev->preg, (u8*)&lcdc_dev->regbak, 0x9C);
  81         return 0;
  82 }
  83
  84 static int init_rk3066b_lcdc(struct rk_lcdc_device_driver *dev_drv)
  85 {
  86         int i=0;
  87         int __iomem *c;
  88         int v;
  89
  90         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
  91
  92         if(lcdc_dev->id == 0) //lcdc0
  93         {
  94                 lcdc_dev->pd = clk_get(NULL,"pd_lcdc0");
  95                 lcdc_dev->hclk = clk_get(NULL,"hclk_lcdc0");
  96                 lcdc_dev->aclk = clk_get(NULL,"aclk_lcdc0");
  97                 lcdc_dev->dclk = clk_get(NULL,"dclk_lcdc0");
  98         }
  99         else if(lcdc_dev->id == 1)
 100         {
 101                 lcdc_dev->pd = clk_get(NULL,"pd_lcdc1");
 102                 lcdc_dev->hclk = clk_get(NULL,"hclk_lcdc1");
 103                 lcdc_dev->aclk = clk_get(NULL,"aclk_lcdc1");
 104                 lcdc_dev->dclk = clk_get(NULL,"dclk_lcdc1");
 105         }
 106         else
 107         {
 108                 printk(KERN_ERR "invalid lcdc device!\n");
 109                 return -EINVAL;
 110         }
 111         if (IS_ERR(lcdc_dev->pd) || (IS_ERR(lcdc_dev->aclk)) ||(IS_ERR(lcdc_dev->dclk)) || (IS_ERR(lcdc_dev->hclk)))
 112         {
 113                 printk(KERN_ERR "failed to get lcdc%d clk source\n",lcdc_dev->id);
 114         }
 115
 116         rk3066b_lcdc_clk_enable(lcdc_dev);
 117
 118         if(lcdc_dev->id == 0)
 119         {
 120                 #if defined(CONFIG_RK3066B_LCDC0_IO_18V)
 121                 v = 0x40004000;               //bit14: 1,1.8v;0,3.3v
 122                 writel_relaxed(v,RK30_GRF_BASE + GRF_IO_CON4);
 123                 #else
 124                 v = 0x40000000;
 125                 writel_relaxed(v,RK30_GRF_BASE + GRF_IO_CON4);
 126                 #endif
 127         }
 128
 129         if(lcdc_dev->id == 1) //iomux for lcdc1
 130         {
 131                 #if defined(CONFIG_RK3066B_LCDC1_IO_18V)
 132                 v = 0x80008000;               //bit14: 1,1.8v;0,3.3v
 133                 writel_relaxed(v,RK30_GRF_BASE + GRF_IO_CON4);
 134                 #else
 135                 v = 0x80000000;
 136                 writel_relaxed(v,RK30_GRF_BASE + GRF_IO_CON4);
 137                 #endif
 138
 139                 iomux_set(LCDC1_DCLK);
 140                 iomux_set(LCDC1_DEN);
 141                 iomux_set(LCDC1_HSYNC);
 142                 iomux_set(LCDC1_VSYNC);
 143                 iomux_set(LCDC1_D0);
 144                 iomux_set(LCDC1_D1);
 145                 iomux_set(LCDC1_D2);
 146                 iomux_set(LCDC1_D3);
 147                 iomux_set(LCDC1_D4);
 148                 iomux_set(LCDC1_D5);
 149                 iomux_set(LCDC1_D6);
 150                 iomux_set(LCDC1_D7);
 151                 iomux_set(LCDC1_D8);
 152                 iomux_set(LCDC1_D9);
 153                 iomux_set(LCDC1_D10);
 154                 iomux_set(LCDC1_D11);
 155                 iomux_set(LCDC1_D12);
 156                 iomux_set(LCDC1_D13);
 157                 iomux_set(LCDC1_D14);
 158                 iomux_set(LCDC1_D15);
 159                 iomux_set(LCDC1_D16);
 160                 iomux_set(LCDC1_D17);
 161                 iomux_set(LCDC1_D18);
 162                 iomux_set(LCDC1_D19);
 163                 iomux_set(LCDC1_D20);
 164                 iomux_set(LCDC1_D21);
 165                 iomux_set(LCDC1_D22);
 166                 iomux_set(LCDC1_D23);
 167
 168         }
 169         LcdMskReg(lcdc_dev,SYS_CFG, m_LCDC_AXICLK_AUTO_ENABLE | m_W0_AXI_OUTSTANDING2 |
 170                 m_W1_AXI_OUTSTANDING2,v_LCDC_AXICLK_AUTO_ENABLE(1) | v_W0_AXI_OUTSTANDING2(1) |
 171                 v_W1_AXI_OUTSTANDING2(1));//eanble axi-clk auto gating for low power
 172          LcdWrReg(lcdc_dev,AXI_MS_ID,v_HWC_CHANNEL_ID(5) | v_WIN2_CHANNEL_ID(4) |
 173                 v_WIN1_YRGB_CHANNEL_ID(3) | v_WIN0_CBR_CHANNEL_ID(2) |
 174                 v_WIN0_YRGB_CHANNEL_ID(1));
 175         LcdMskReg(lcdc_dev, INT_STATUS,m_HOR_STARTMASK| m_FRM_STARTMASK |
 176               m_SCANNING_MASK, v_HOR_STARTMASK(1) | v_FRM_STARTMASK(1) |
 177               v_SCANNING_MASK(1));  //mask all interrupt in init
 178         LcdMskReg(lcdc_dev,FIFO_WATER_MARK,m_WIN1_FIFO_FULL_LEVEL,v_WIN1_FIFO_FULL_LEVEL(0x1e0));
 179         //LCDC_REG_CFG_DONE();  // write any value to  REG_CFG_DONE let config become effective
 180         if(dev_drv->cur_screen->dsp_lut)                        //resume dsp lut
 181         {
 182                 LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(0));
 183                 LCDC_REG_CFG_DONE();
 184
 185                 mdelay(25); //wait for dsp lut disabled
 186                 for(i=0;i<256;i++)
 187                 {
 188                         v = dev_drv->cur_screen->dsp_lut[i];
 189                         c = lcdc_dev->dsp_lut_addr_base+i;
 190                         writel_relaxed(v,c);
 191                 }
 192                 LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(1));//enable dsp lut
 193         }
 194
 195         rk3066b_lcdc_clk_disable(lcdc_dev);
 196         return 0;
 197 }
 198
 199 static int rk3066b_lcdc_deinit(struct rk3066b_lcdc_device *lcdc_dev)
 200 {
 201         spin_lock(&lcdc_dev->reg_lock);
 202         if(likely(lcdc_dev->clk_on))
 203         {
 204                 lcdc_dev->clk_on = 0;
 205                 LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_STARTCLEAR, v_FRM_STARTCLEAR(1));
 206                 LcdMskReg(lcdc_dev, INT_STATUS,m_HOR_STARTMASK| m_FRM_STARTMASK |
 207                           m_SCANNING_MASK, v_HOR_STARTMASK(1) | v_FRM_STARTMASK(1) |
 208                           v_SCANNING_MASK(1));  //mask all interrupt in init
 209                 LcdSetBit(lcdc_dev,SYS_CFG,m_LCDC_STANDBY);
 210                 LCDC_REG_CFG_DONE();
 211                 spin_unlock(&lcdc_dev->reg_lock);
 212         }
 213         else   //clk already disabled
 214         {
 215                 spin_unlock(&lcdc_dev->reg_lock);
 216                 return 0;
 217         }
 218         mdelay(1);
 219
 220         return 0;
 221 }
 222
 223 static int rk3066b_load_screen(struct rk_lcdc_device_driver *dev_drv, bool initscreen)
 224 {
 225         int ret = -EINVAL;
 226         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 227         rk_screen *screen = dev_drv->cur_screen;
 228         u64 ft;
 229         int fps;
 230         u16 face;
 231         u16 mcu_total, mcu_rwstart, mcu_csstart, mcu_rwend, mcu_csend;
 232         u16 right_margin = screen->right_margin;
 233         u16 lower_margin = screen->lower_margin;
 234         u16 x_res = screen->x_res, y_res = screen->y_res;
 235
 236         // set the rgb or mcu
 237         spin_lock(&lcdc_dev->reg_lock);
 238         if(likely(lcdc_dev->clk_on))
 239         {
 240                 if(screen->type==SCREEN_MCU)
 241                 {
 242                         LcdMskReg(lcdc_dev, MCU_CTRL, m_MCU_OUTPUT_SELECT,v_MCU_OUTPUT_SELECT(1));
 243                         // set out format and mcu timing
 244                         mcu_total  = (screen->mcu_wrperiod*150*1000)/1000000;
 245                         if(mcu_total>31)
 246                                 mcu_total = 31;
 247                         if(mcu_total<3)
 248                                 mcu_total = 3;
 249                         mcu_rwstart = (mcu_total+1)/4 - 1;
 250                         mcu_rwend = ((mcu_total+1)*3)/4 - 1;
 251                         mcu_csstart = (mcu_rwstart>2) ? (mcu_rwstart-3) : (0);
 252                         mcu_csend = (mcu_rwend>15) ? (mcu_rwend-1) : (mcu_rwend);
 253
 254                         //DBG(1,">> mcu_total=%d, mcu_rwstart=%d, mcu_csstart=%d, mcu_rwend=%d, mcu_csend=%d \n",
 255                         //      mcu_total, mcu_rwstart, mcu_csstart, mcu_rwend, mcu_csend);
 256
 257                         // set horizontal & vertical out timing
 258
 259                         right_margin = x_res/6;
 260                         screen->pixclock = 150000000; //mcu fix to 150 MHz
 261                         LcdMskReg(lcdc_dev, MCU_CTRL,m_MCU_CS_ST | m_MCU_CS_END| m_MCU_RW_ST | m_MCU_RW_END |
 262                                 m_MCU_WRITE_PERIOD | m_MCU_HOLDMODE_SELECT | m_MCU_HOLDMODE_FRAME_ST,
 263                                 v_MCU_CS_ST(mcu_csstart) | v_MCU_CS_END(mcu_csend) | v_MCU_RW_ST(mcu_rwstart) |
 264                                 v_MCU_RW_END(mcu_rwend) |  v_MCU_WRITE_PERIOD(mcu_total) |
 265                                 v_MCU_HOLDMODE_SELECT((SCREEN_MCU==screen->type)?(1):(0)) | v_MCU_HOLDMODE_FRAME_ST(0));
 266
 267                 }
 268
 269                 switch (screen->face)
 270                 {
 271                         case OUT_P565:
 272                                 face = OUT_P565;
 273                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
 274                                 break;
 275                         case OUT_P666:
 276                                 face = OUT_P666;
 277                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
 278                                 break;
 279                         case OUT_D888_P565:
 280                                 face = OUT_P888;
 281                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
 282                                 break;
 283                         case OUT_D888_P666:
 284                                 face = OUT_P888;
 285                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
 286                                 break;
 287                         case OUT_P888:
 288                                 face = OUT_P888;
 289                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_UP_EN, v_DITHER_UP_EN(1));
 290                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(0) | v_DITHER_DOWN_MODE(0));
 291                                 break;
 292                         default:
 293                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_UP_EN, v_DITHER_UP_EN(0));
 294                                 LcdMskReg(lcdc_dev, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(0) | v_DITHER_DOWN_MODE(0));
 295                                 face = screen->face;
 296                                 break;
 297                 }
 298
 299                 //use default overlay,set vsyn hsync den dclk polarity
 300                 LcdMskReg(lcdc_dev, DSP_CTRL0,m_DISPLAY_FORMAT | m_HSYNC_POLARITY | m_VSYNC_POLARITY |
 301                         m_DEN_POLARITY |m_DCLK_POLARITY,v_DISPLAY_FORMAT(face) |
 302                         v_HSYNC_POLARITY(screen->pin_hsync) | v_VSYNC_POLARITY(screen->pin_vsync) |
 303                         v_DEN_POLARITY(screen->pin_den) | v_DCLK_POLARITY(screen->pin_dclk));
 304
 305                 //set background color to black,set swap according to the screen panel,disable blank mode
 306                 LcdMskReg(lcdc_dev,DSP_CTRL1,m_BLANK_MODE | m_BLACK_MODE | m_BG_COLOR, v_BLANK_MODE(0) |
 307                                         v_BLACK_MODE(0) | v_BG_COLOR(0x000000));
 308                 LcdMskReg(lcdc_dev,SWAP_CTRL,m_OUTPUT_RB_SWAP | m_OUTPUT_RG_SWAP | m_DELTA_SWAP | m_DUMMY_SWAP,
 309                                         v_OUTPUT_RB_SWAP(screen->swap_rb) | v_OUTPUT_RG_SWAP(screen->swap_rg) |
 310                                         v_DELTA_SWAP(screen->swap_delta) | v_DUMMY_SWAP(screen->swap_dumy));
 311                 LcdWrReg(lcdc_dev, DSP_HTOTAL_HS_END,v_HSYNC(screen->hsync_len) |
 312                      v_HORPRD(screen->hsync_len + screen->left_margin + x_res + right_margin));
 313                 LcdWrReg(lcdc_dev, DSP_HACT_ST_END, v_HAEP(screen->hsync_len + screen->left_margin + x_res) |
 314                      v_HASP(screen->hsync_len + screen->left_margin));
 315
 316                 LcdWrReg(lcdc_dev, DSP_VTOTAL_VS_END, v_VSYNC(screen->vsync_len) |
 317                       v_VERPRD(screen->vsync_len + screen->upper_margin + y_res + lower_margin));
 318                 LcdWrReg(lcdc_dev, DSP_VACT_ST_END,  v_VAEP(screen->vsync_len + screen->upper_margin+y_res)|
 319                       v_VASP(screen->vsync_len + screen->upper_margin));
 320                 // let above to take effect
 321                 //LCDC_REG_CFG_DONE();
 322         }
 323         spin_unlock(&lcdc_dev->reg_lock);
 324
 325         ret = clk_set_rate(lcdc_dev->dclk, screen->pixclock);
 326         if(ret)
 327         {
 328                 printk(KERN_ERR ">>>>>> set lcdc%d dclk failed\n",lcdc_dev->id);
 329         }
 330         lcdc_dev->driver.pixclock = lcdc_dev->pixclock = div_u64(1000000000000llu, clk_get_rate(lcdc_dev->dclk));
 331
 332
 333         ft = (u64)(screen->upper_margin + screen->lower_margin + screen->y_res +screen->vsync_len)*
 334                 (screen->left_margin + screen->right_margin + screen->x_res + screen->hsync_len)*
 335                 (dev_drv->pixclock);       // one frame time ,(pico seconds)
 336         fps = div64_u64(1000000000000llu,ft);
 337         screen->ft = 1000/fps;
 338         printk("%s: dclk:%lu>>fps:%d ",lcdc_dev->driver.name,clk_get_rate(lcdc_dev->dclk),fps);
 339
 340         if(screen->init)
 341         {
 342                 screen->init();
 343         }
 344         printk("%s for lcdc%d ok!\n",__func__,lcdc_dev->id);
 345         return 0;
 346 }
 347
 348 static int mcu_refresh(struct rk3066b_lcdc_device *lcdc_dev)
 349 {
 350
 351     return 0;
 352 }
 353
 354
 355
 356 //enable layer,open:1,enable;0 disable
 357 static int win0_open(struct rk3066b_lcdc_device *lcdc_dev,bool open)
 358 {
 359
 360         spin_lock(&lcdc_dev->reg_lock);
 361         if(likely(lcdc_dev->clk_on))
 362         {
 363                 if(open)
 364                 {
 365                         if(!lcdc_dev->atv_layer_cnt)
 366                         {
 367                                 LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(0));
 368                         }
 369                         lcdc_dev->atv_layer_cnt++;
 370                 }
 371                 else
 372                 {
 373                         lcdc_dev->atv_layer_cnt--;
 374                 }
 375                 lcdc_dev->driver.layer_par[0]->state = open;
 376
 377                 LcdMskReg(lcdc_dev, SYS_CFG, m_W0_EN, v_W0_EN(open));
 378                 if(!lcdc_dev->atv_layer_cnt)  //if no layer used,disable lcdc
 379                 {
 380                         LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(1));
 381                 }
 382                 //LCDC_REG_CFG_DONE();
 383         }
 384         spin_unlock(&lcdc_dev->reg_lock);
 385         printk(KERN_INFO "lcdc%d win0 %s\n",lcdc_dev->id,open?"open":"closed");
 386         return 0;
 387 }
 388 static int win1_open(struct rk3066b_lcdc_device *lcdc_dev,bool open)
 389 {
 390         spin_lock(&lcdc_dev->reg_lock);
 391         if(likely(lcdc_dev->clk_on))
 392         {
 393                 if(open)
 394                 {
 395                         if(!lcdc_dev->atv_layer_cnt)
 396                         {
 397                                 printk("lcdc%d wakeup from stanby\n",lcdc_dev->id);
 398                                 LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(0));
 399                         }
 400                         lcdc_dev->atv_layer_cnt++;
 401                 }
 402                 else
 403                 {
 404                         lcdc_dev->atv_layer_cnt--;
 405                 }
 406                 lcdc_dev->driver.layer_par[1]->state = open;
 407
 408                 LcdMskReg(lcdc_dev, SYS_CFG, m_W1_EN, v_W1_EN(open));
 409                 if(!lcdc_dev->atv_layer_cnt)  //if no layer used,disable lcdc
 410                 {
 411                         printk(KERN_INFO "no layer of lcdc%d is used,go to standby!",lcdc_dev->id);
 412                         LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(1));
 413                 }
 414                 LCDC_REG_CFG_DONE();
 415         }
 416         spin_unlock(&lcdc_dev->reg_lock);
 417         printk(KERN_INFO "lcdc%d win1 %s\n",lcdc_dev->id,open?"open":"closed");
 418         return 0;
 419 }
 420
 421
 422 static int rk3066b_lcdc_blank(struct rk_lcdc_device_driver*lcdc_drv,int layer_id,int blank_mode)
 423 {
 424         struct rk3066b_lcdc_device * lcdc_dev = container_of(lcdc_drv,struct rk3066b_lcdc_device ,driver);
 425
 426         spin_lock(&lcdc_dev->reg_lock);
 427         if(likely(lcdc_dev->clk_on))
 428         {
 429                 switch(blank_mode)
 430                 {
 431                         case FB_BLANK_UNBLANK:
 432                                 LcdMskReg(lcdc_dev,DSP_CTRL1,m_BLANK_MODE ,v_BLANK_MODE(0));
 433                                 break;
 434                         case FB_BLANK_NORMAL:
 435                                 LcdMskReg(lcdc_dev,DSP_CTRL1,m_BLANK_MODE ,v_BLANK_MODE(1));
 436                                 break;
 437                         default:
 438                                 LcdMskReg(lcdc_dev,DSP_CTRL1,m_BLANK_MODE ,v_BLANK_MODE(1));
 439                                 break;
 440                 }
 441                 LCDC_REG_CFG_DONE();
 442                 printk(KERN_INFO "%s>>>>>%d\n",__func__, blank_mode);
 443         }
 444         spin_unlock(&lcdc_dev->reg_lock);
 445
 446         return 0;
 447 }
 448
 449 static  int win0_display(struct rk3066b_lcdc_device *lcdc_dev,struct layer_par *par )
 450 {
 451         u32 y_addr;
 452         u32 uv_addr;
 453         y_addr = par->smem_start + par->y_offset;
 454         uv_addr = par->cbr_start + par->c_offset;
 455         DBG(2,KERN_INFO "lcdc%d>>%s:y_addr:0x%x>>uv_addr:0x%x\n",lcdc_dev->id,__func__,y_addr,uv_addr);
 456
 457         spin_lock(&lcdc_dev->reg_lock);
 458         if(likely(lcdc_dev->clk_on))
 459         {
 460                 LcdWrReg(lcdc_dev, WIN0_YRGB_MST,y_addr);
 461                 LcdWrReg(lcdc_dev, WIN0_CBR_MST,uv_addr);
 462                 LCDC_REG_CFG_DONE();
 463         }
 464         spin_unlock(&lcdc_dev->reg_lock);
 465
 466         return 0;
 467
 468 }
 469
 470 static  int win1_display(struct rk3066b_lcdc_device *lcdc_dev,struct layer_par *par )
 471 {
 472         u32 y_addr;
 473         u32 uv_addr;
 474         y_addr = par->smem_start + par->y_offset;
 475         uv_addr = par->cbr_start + par->c_offset;
 476         DBG(2,KERN_INFO "lcdc%d>>%s>>y_addr:0x%x>>uv_addr:0x%x\n",lcdc_dev->id,__func__,y_addr,uv_addr);
 477
 478         spin_lock(&lcdc_dev->reg_lock);
 479         if(likely(lcdc_dev->clk_on))
 480         {
 481                 LcdWrReg(lcdc_dev, WIN1_YRGB_MST, y_addr);
 482                 LCDC_REG_CFG_DONE();
 483         }
 484         spin_unlock(&lcdc_dev->reg_lock);
 485
 486         return 0;
 487 }
 488
 489 static  int win0_set_par(struct rk3066b_lcdc_device *lcdc_dev,rk_screen *screen,
 490         struct layer_par *par )
 491 {
 492         u32 xact, yact, xvir, yvir, xpos, ypos;
 493         u32 ScaleYrgbX = 0x1000;
 494         u32 ScaleYrgbY = 0x1000;
 495         u32 ScaleCbrX = 0x1000;
 496         u32 ScaleCbrY = 0x1000;
 497         u8 fmt_cfg =0 ; //data format register config value
 498         char fmt[9] = "NULL";
 499         xact = par->xact;                           //active (origin) picture window width/height
 500         yact = par->yact;
 501         xvir = par->xvir;                          // virtual resolution
 502         yvir = par->yvir;
 503         xpos = par->xpos+screen->left_margin + screen->hsync_len;
 504         ypos = par->ypos+screen->upper_margin + screen->vsync_len;
 505
 506         DBG(1,"%s for lcdc%d>>format:%s>>>xact:%d>>yact:%d>>xsize:%d>>ysize:%d>>xvir:%d>>yvir:%d>>xpos:%d>>ypos:%d>>\n",
 507                 __func__,lcdc_dev->id,get_format_string(par->format,fmt),xact,yact,par->xsize,par->ysize,xvir,yvir,xpos,ypos);
 508
 509         ScaleYrgbX = CalScale(xact, par->xsize); //both RGB and yuv need this two factor
 510         ScaleYrgbY = CalScale(yact, par->ysize);
 511         switch (par->format)
 512         {
 513                 case XBGR888:
 514                 case ABGR888:
 515                 case ARGB888:
 516                         fmt_cfg = 0;
 517                         break;
 518                 case RGB565:
 519                         fmt_cfg = 1;
 520                         break;
 521                 case YUV422:// yuv422
 522                         fmt_cfg = 2;
 523                         ScaleCbrX = CalScale((xact/2), par->xsize);
 524                         ScaleCbrY = CalScale(yact, par->ysize);
 525                         break;
 526                 case YUV420: // yuv420
 527                         fmt_cfg = 3;
 528                         ScaleCbrX = CalScale(xact/2, par->xsize);
 529                         ScaleCbrY = CalScale(yact/2, par->ysize);
 530                         break;
 531                 case YUV444:// yuv444
 532                         fmt_cfg = 4;
 533                         ScaleCbrX = CalScale(xact, par->xsize);
 534                         ScaleCbrY = CalScale(yact, par->ysize);
 535                         break;
 536                 default:
 537                         printk("%s:un supported format\n",__func__);
 538                    break;
 539         }
 540
 541
 542         spin_lock(&lcdc_dev->reg_lock);
 543         if(likely(lcdc_dev->clk_on))
 544         {
 545                 LcdWrReg(lcdc_dev, WIN0_SCL_FACTOR_YRGB, v_X_SCL_FACTOR(ScaleYrgbX) | v_Y_SCL_FACTOR(ScaleYrgbY));
 546                 LcdWrReg(lcdc_dev, WIN0_SCL_FACTOR_CBR,v_X_SCL_FACTOR(ScaleCbrX)| v_Y_SCL_FACTOR(ScaleCbrY));
 547                 LcdMskReg(lcdc_dev,SYS_CFG, m_W0_FORMAT, v_W0_FORMAT(fmt_cfg));         //(inf->video_mode==0)
 548                 LcdWrReg(lcdc_dev, WIN0_ACT_INFO,v_ACT_WIDTH(xact) | v_ACT_HEIGHT(yact));
 549                 LcdWrReg(lcdc_dev, WIN0_DSP_ST, v_DSP_STX(xpos) | v_DSP_STY(ypos));
 550                 LcdWrReg(lcdc_dev, WIN0_DSP_INFO, v_DSP_WIDTH(par->xsize)| v_DSP_HEIGHT(par->ysize));
 551                 LcdMskReg(lcdc_dev, WIN0_COLOR_KEY_CTRL, m_COLORKEY_EN | m_KEYCOLOR,
 552                         v_COLORKEY_EN(0) | v_KEYCOLOR(0));
 553                 LcdWrReg(lcdc_dev,WIN0_VIR,v_VIRWIDTH(xvir));
 554                 //LCDC_REG_CFG_DONE();
 555         }
 556         spin_unlock(&lcdc_dev->reg_lock);
 557
 558     return 0;
 559
 560 }
 561
 562 static int win1_set_par(struct rk3066b_lcdc_device *lcdc_dev,rk_screen *screen,
 563         struct layer_par *par )
 564 {
 565         u32 xact, yact, xvir, yvir, xpos, ypos;
 566         u8 fmt_cfg;
 567         char fmt[9]="NULL";
 568         xact = par->xact;
 569         yact = par->yact;
 570         xvir = par->xvir;
 571         yvir = par->yvir;
 572         xpos = par->xpos+screen->left_margin + screen->hsync_len;
 573         ypos = par->ypos+screen->upper_margin + screen->vsync_len;
 574
 575
 576         DBG(1,"%s for lcdc%d>>format:%s>>>xact:%d>>yact:%d>>xsize:%d>>ysize:%d>>xvir:%d>>yvir:%d>>xpos:%d>>ypos:%d>>\n",
 577                 __func__,lcdc_dev->id,get_format_string(par->format,fmt),xact,yact,par->xsize,par->ysize,xvir,yvir,xpos,ypos);
 578
 579
 580         spin_lock(&lcdc_dev->reg_lock);
 581         if(likely(lcdc_dev->clk_on))
 582         {
 583                 switch (par->format)
 584                 {
 585                         case XBGR888:
 586                         case ABGR888:
 587                         case ARGB888:
 588                                 fmt_cfg = 0;
 589                                 break;
 590                         case RGB565:
 591                                 fmt_cfg = 1;
 592                                 break;
 593                         default:
 594                                 printk("%s:un supported format\n",__func__);
 595                                 break;
 596                 }
 597
 598                 LcdMskReg(lcdc_dev,SYS_CFG, m_W1_FORMAT, v_W1_FORMAT(fmt_cfg));
 599                 LcdWrReg(lcdc_dev, WIN1_DSP_ST,v_DSP_STX(xpos) | v_DSP_STY(ypos));
 600                 LcdWrReg(lcdc_dev, WIN1_DSP_INFO,v_DSP_WIDTH(par->xsize) | v_DSP_HEIGHT(par->ysize));
 601                 // enable win1 color key and set the color to black(rgb=0)
 602                 LcdMskReg(lcdc_dev,WIN1_COLOR_KEY_CTRL, m_COLORKEY_EN | m_KEYCOLOR,v_COLORKEY_EN(1) | v_KEYCOLOR(0));
 603                 LcdWrReg(lcdc_dev,WIN1_VIR,v_VIRWIDTH(xvir));
 604
 605                 //LCDC_REG_CFG_DONE();
 606         }
 607         spin_unlock(&lcdc_dev->reg_lock);
 608     return 0;
 609 }
 610
 611 static int rk3066b_lcdc_open(struct rk_lcdc_device_driver *dev_drv,int layer_id,bool open)
 612 {
 613         int i=0;
 614         int __iomem *c;
 615         int v;
 616         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 617
 618         if((open) && (!lcdc_dev->atv_layer_cnt)) //enable clk,when first layer open
 619         {
 620                 rk3066b_lcdc_clk_enable(lcdc_dev);
 621                 rk3066b_lcdc_reg_resume(lcdc_dev); //resume reg
 622                 LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(0));
 623                 rk3066b_load_screen(dev_drv,1);
 624                 spin_lock(&lcdc_dev->reg_lock);
 625                 if(dev_drv->cur_screen->dsp_lut)                        //resume dsp lut
 626                 {
 627                         LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(0));
 628                         LCDC_REG_CFG_DONE();
 629
 630                         mdelay(25); //wait for dsp lut disabled
 631                         for(i=0;i<256;i++)
 632                         {
 633                                 v = dev_drv->cur_screen->dsp_lut[i];
 634                                 c = lcdc_dev->dsp_lut_addr_base+i;
 635                                 writel_relaxed(v,c);
 636                         }
 637                         LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(1));//enable dsp lut
 638                 }
 639                 spin_unlock(&lcdc_dev->reg_lock);
 640         }
 641         if(layer_id == 0)
 642         {
 643                 win0_open(lcdc_dev,open);
 644         }
 645         else if(layer_id == 1)
 646         {
 647                 win1_open(lcdc_dev,open);
 648         }
 649
 650         if((!open) && (!lcdc_dev->atv_layer_cnt))  //when all layer closed,disable clk
 651         {
 652                 LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_STARTCLEAR, v_FRM_STARTCLEAR(1));
 653                 LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(1));
 654                 LCDC_REG_CFG_DONE();
 655                 rk3066b_lcdc_clk_disable(lcdc_dev);
 656         }
 657         return 0;
 658 }
 659
 660 static int rk3066b_lcdc_set_par(struct rk_lcdc_device_driver *dev_drv,int layer_id)
 661 {
 662         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 663         struct layer_par *par = NULL;
 664         rk_screen *screen = dev_drv->cur_screen;
 665         if(!screen)
 666         {
 667                 printk(KERN_ERR "screen is null!\n");
 668                 return -ENOENT;
 669         }
 670         if(layer_id==0)
 671         {
 672                 par = dev_drv->layer_par[0];
 673                 win0_set_par(lcdc_dev,screen,par);
 674         }
 675         else if(layer_id==1)
 676         {
 677                 par = dev_drv->layer_par[1];
 678                 win1_set_par(lcdc_dev,screen,par);
 679         }
 680
 681         return 0;
 682 }
 683
 684 int rk3066b_lcdc_pan_display(struct rk_lcdc_device_driver * dev_drv,int layer_id)
 685 {
 686         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 687         struct layer_par *par = NULL;
 688         rk_screen *screen = dev_drv->cur_screen;
 689         unsigned long flags;
 690         int timeout;
 691         if(!screen)
 692         {
 693                 printk(KERN_ERR "screen is null!\n");
 694                 return -ENOENT;
 695         }
 696         if(layer_id==0)
 697         {
 698                 par = dev_drv->layer_par[0];
 699                 win0_display(lcdc_dev,par);
 700         }
 701         else if(layer_id==1)
 702         {
 703                 par = dev_drv->layer_par[1];
 704                 win1_display(lcdc_dev,par);
 705         }
 706         if((dev_drv->first_frame))  //this is the first frame of the system ,enable frame start interrupt
 707         {
 708                 dev_drv->first_frame = 0;
 709                 LcdMskReg(lcdc_dev,INT_STATUS,m_HOR_STARTMASK | m_FRM_STARTMASK | m_SCANNING_MASK |
 710                         m_HOR_STARTCLEAR | m_FRM_STARTCLEAR |m_SCANNING_CLEAR | m_SCAN_LINE_NUM,
 711                           v_HOR_STARTMASK(1) | v_FRM_STARTMASK(0) | v_SCANNING_MASK(0) |
 712                           v_HOR_STARTCLEAR(1) | v_FRM_STARTCLEAR(1) | v_SCANNING_CLEAR(1) |
 713                           //v_SCANNING_CLEAR(screen->vsync_len + screen->upper_margin+screen->y_res -1));
 714                           v_SCAN_LINE_NUM(screen->vsync_len + screen->upper_margin+screen->y_res -1));
 715                 LCDC_REG_CFG_DONE();  // write any value to  REG_CFG_DONE let config become effective
 716
 717         }
 718
 719 #if 0
 720         if(dev_drv->num_buf < 3) //3buffer ,no need to  wait for sysn
 721         {
 722                 spin_lock_irqsave(&dev_drv->cpl_lock,flags);
 723                 init_completion(&dev_drv->frame_done);
 724                 spin_unlock_irqrestore(&dev_drv->cpl_lock,flags);
 725                 timeout = wait_for_completion_timeout(&dev_drv->frame_done,msecs_to_jiffies(dev_drv->cur_screen->ft+5));
 726                 if(!timeout&&(!dev_drv->frame_done.done))
 727                 {
 728                         printk(KERN_ERR "wait for new frame start time out!\n");
 729                         return -ETIMEDOUT;
 730                 }
 731         }
 732 #endif
 733
 734         return 0;
 735 }
 736
 737 int rk3066b_lcdc_ioctl(struct rk_lcdc_device_driver * dev_drv,unsigned int cmd, unsigned long arg,int layer_id)
 738 {
 739         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 740         u32 panel_size[2];
 741         void __user *argp = (void __user *)arg;
 742         int ret = 0;
 743         switch(cmd)
 744         {
 745                 case RK_FBIOGET_PANEL_SIZE:    //get panel size
 746                         panel_size[0] = lcdc_dev->screen->x_res;
 747                         panel_size[1] = lcdc_dev->screen->y_res;
 748                         if(copy_to_user(argp, panel_size, 8))
 749                                 return -EFAULT;
 750                         break;
 751                 default:
 752                         break;
 753         }
 754
 755         return ret;
 756 }
 757 static int rk3066b_lcdc_get_layer_state(struct rk_lcdc_device_driver *dev_drv,int layer_id)
 758 {
 759         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 760         struct layer_par *par = dev_drv->layer_par[layer_id];
 761
 762         spin_lock(&lcdc_dev->reg_lock);
 763         if(lcdc_dev->clk_on)
 764         {
 765                 if(layer_id == 0)
 766                 {
 767                         par->state = LcdReadBit(lcdc_dev,SYS_CFG,m_W0_EN);
 768                 }
 769                 else if( layer_id == 1)
 770                 {
 771                         par->state = LcdReadBit(lcdc_dev,SYS_CFG,m_W1_EN);
 772                 }
 773         }
 774         spin_unlock(&lcdc_dev->reg_lock);
 775
 776         return par->state;
 777
 778 }
 779
 780 /***********************************
 781 overlay manager
 782 swap:1 win0 on the top of win1
 783         0 win1 on the top of win0
 784 set  : 1 set overlay
 785         0 get overlay state
 786 ************************************/
 787 static int rk3066b_lcdc_ovl_mgr(struct rk_lcdc_device_driver *dev_drv,int swap,bool set)
 788 {
 789         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 790         int ovl;
 791         spin_lock(&lcdc_dev->reg_lock);
 792         if(lcdc_dev->clk_on)
 793         {
 794                 if(set)  //set overlay
 795                 {
 796                         LcdMskReg(lcdc_dev,DSP_CTRL0,m_W0W1_POSITION_SWAP,v_W0W1_POSITION_SWAP(swap));
 797                         LcdWrReg(lcdc_dev, REG_CFG_DONE, 0x01);
 798                         LCDC_REG_CFG_DONE();
 799                         ovl = swap;
 800                 }
 801                 else  //get overlay
 802                 {
 803                         ovl = LcdReadBit(lcdc_dev,DSP_CTRL0,m_W0W1_POSITION_SWAP);
 804                 }
 805         }
 806         else
 807         {
 808                 ovl = -EPERM;
 809         }
 810         spin_unlock(&lcdc_dev->reg_lock);
 811
 812         return ovl;
 813 }
 814
 815 static ssize_t rk3066b_lcdc_get_disp_info(struct rk_lcdc_device_driver *dev_drv,char *buf,int layer_id)
 816
 817 {
 818         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 819         char format_w0[9]= "NULL";
 820         char format_w1[9]= "NULL";
 821         char status_w0[9]= "NULL";
 822         char status_w1[9]= "NULL";
 823         u32 fmt_id = LcdRdReg(lcdc_dev,SYS_CFG);
 824         u32 act_info,dsp_info,dsp_st,factor;
 825         u16 xvir_w0,x_act_w0,y_act_w0,x_dsp_w0,y_dsp_w0,x_st_w0,y_st_w0;
 826         u16 xvir_w1,x_dsp_w1,y_dsp_w1,x_st_w1,y_st_w1;
 827         u16 x_scale,y_scale;
 828         int ovl = LcdReadBit(lcdc_dev,DSP_CTRL0,m_W0W1_POSITION_SWAP);
 829
 830         switch((fmt_id&m_W0_FORMAT)>>3)
 831         {
 832                 case 0:
 833                         strcpy(format_w0,"ARGB888");
 834                         break;
 835                 case 1:
 836                         strcpy(format_w0,"RGB565");
 837                         break;
 838                 case 2:
 839                         strcpy(format_w0,"YCbCr422");
 840                         break;
 841                 case 3:
 842                         strcpy(format_w0,"YCbCr420");
 843                         break;
 844                 case 5:
 845                         strcpy(format_w0,"YCbCr444");
 846                         break;
 847                 default:
 848                         strcpy(format_w0,"invalid\n");
 849                         break;
 850         }
 851
 852          switch((fmt_id&m_W1_FORMAT)>>2)
 853         {
 854                 case 0:
 855                         strcpy(format_w1,"ARGB888");
 856                         break;
 857                 case 1:
 858                         strcpy(format_w1,"RGB565");
 859                         break;
 860                 default:
 861                         strcpy(format_w1,"invalid\n");
 862                         break;
 863         }
 864
 865         if((fmt_id&m_W0_EN)>>11)
 866         {
 867                 strcpy(status_w0,"enabled");
 868         }
 869         else
 870         {
 871                 strcpy(status_w0,"disabled");
 872         }
 873
 874         if((fmt_id&m_W1_EN)>>10)
 875         {
 876                 strcpy(status_w1,"enabled");
 877         }
 878         else
 879         {
 880                 strcpy(status_w1,"disabled");
 881         }
 882
 883         xvir_w0 = LcdRdReg(lcdc_dev,WIN0_VIR)&0xffff;
 884         act_info = LcdRdReg(lcdc_dev,WIN0_ACT_INFO);
 885         dsp_info = LcdRdReg(lcdc_dev,WIN0_DSP_INFO);
 886         dsp_st = LcdRdReg(lcdc_dev,WIN0_DSP_ST);
 887         factor = LcdRdReg(lcdc_dev,WIN0_SCL_FACTOR_YRGB);
 888         x_act_w0 =  (act_info&0xffff);
 889         y_act_w0 = (act_info>>16);
 890         x_dsp_w0 = (dsp_info&0x7ff);
 891         y_dsp_w0 = (dsp_info>>16);
 892         x_scale = 4096*100/(factor&0xffff);
 893         y_scale = 4096*100/(factor>>16);
 894         x_st_w0 = dsp_st&0xffff;
 895         y_st_w0 = dsp_st>>16;
 896
 897
 898         xvir_w1 = LcdRdReg(lcdc_dev,WIN1_VIR)&0xffff;
 899         dsp_info = LcdRdReg(lcdc_dev,WIN1_DSP_INFO);
 900         dsp_st = LcdRdReg(lcdc_dev,WIN1_DSP_ST);
 901         x_dsp_w1 = dsp_info&0x7ff;
 902         y_dsp_w1 = dsp_info>>16;
 903         x_st_w1 = dsp_st&0xffff;
 904         y_st_w1 = dsp_st>>16;
 905
 906         return snprintf(buf,PAGE_SIZE,
 907                 "win0:%s\n"
 908                 "xvir:%d\n"
 909                 "xact:%d\n"
 910                 "yact:%d\n"
 911                 "xdsp:%d\n"
 912                 "ydsp:%d\n"
 913                 "x_st:%d\n"
 914                 "y_st:%d\n"
 915                 "x_scale:%d.%d\n"
 916                 "y_scale:%d.%d\n"
 917                 "format:%s\n"
 918                 "YRGB buffer addr:0x%08x\n"
 919                 "CBR buffer addr:0x%08x\n\n"
 920                 "win1:%s\n"
 921                 "xvir:%d\n"
 922                 "xdsp:%d\n"
 923                 "ydsp:%d\n"
 924                 "x_st:%d\n"
 925                 "y_st:%d\n"
 926                 "format:%s\n"
 927                 "YRGB buffer addr:0x%08x\n"
 928                 "overlay:%s\n",
 929                 status_w0,
 930                 xvir_w0,
 931                 x_act_w0,
 932                 y_act_w0,
 933                 x_dsp_w0,
 934                 y_dsp_w0,
 935                 x_st_w0,
 936                 y_st_w0,
 937                 x_scale/100,
 938                 x_scale%100,
 939                 y_scale/100,
 940                 y_scale%100,
 941                 format_w0,
 942                 LcdRdReg(lcdc_dev,WIN0_YRGB_MST),
 943                 LcdRdReg(lcdc_dev,WIN0_CBR_MST),
 944                 status_w1,
 945                 xvir_w1,
 946                 x_dsp_w1,
 947                 y_dsp_w1,
 948                 x_st_w1,
 949                 y_st_w1,
 950                 format_w1,
 951                 LcdRdReg(lcdc_dev,WIN1_YRGB_MST),
 952                 ovl ? "win0 on the top of win1\n":"win1 on the top of win0\n");
 953         return 0;
 954 }
 955
 956
 957 /*******************************************
 958 lcdc fps manager,set or get lcdc fps
 959 set:0 get
 960      1 set
 961 ********************************************/
 962 static int rk3066b_lcdc_fps_mgr(struct rk_lcdc_device_driver *dev_drv,int fps,bool set)
 963 {
 964         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
 965         rk_screen * screen = dev_drv->cur_screen;
 966         u64 ft = 0;
 967         u32 dotclk;
 968         int ret;
 969
 970         if(set)
 971         {
 972                 ft = div_u64(1000000000000llu,fps);
 973                 dev_drv->pixclock = div_u64(ft,(screen->upper_margin + screen->lower_margin + screen->y_res +screen->vsync_len)*
 974                                 (screen->left_margin + screen->right_margin + screen->x_res + screen->hsync_len));
 975                 dotclk = div_u64(1000000000000llu,dev_drv->pixclock);
 976                 ret = clk_set_rate(lcdc_dev->dclk, dotclk);
 977                 if(ret)
 978                 {
 979                         printk(KERN_ERR ">>>>>> set lcdc%d dclk failed\n",lcdc_dev->id);
 980                 }
 981                 dev_drv->pixclock = lcdc_dev->pixclock = div_u64(1000000000000llu, clk_get_rate(lcdc_dev->dclk));
 982
 983         }
 984
 985         ft = (u64)(screen->upper_margin + screen->lower_margin + screen->y_res +screen->vsync_len)*
 986         (screen->left_margin + screen->right_margin + screen->x_res + screen->hsync_len)*
 987         (dev_drv->pixclock);       // one frame time ,(pico seconds)
 988         fps = div64_u64(1000000000000llu,ft);
 989         screen->ft = 1000/fps ;  //one frame time in ms
 990         return fps;
 991 }
 992
 993 static int rk3066b_fb_layer_remap(struct rk_lcdc_device_driver *dev_drv,
 994         enum fb_win_map_order order)
 995 {
 996         mutex_lock(&dev_drv->fb_win_id_mutex);
 997         if(order == FB_DEFAULT_ORDER)
 998         {
 999                 order = FB0_WIN0_FB1_WIN1_FB2_WIN2;
1000         }
1001         dev_drv->fb2_win_id  = order/100;
1002         dev_drv->fb1_win_id = (order/10)%10;
1003         dev_drv->fb0_win_id = order%10;
1004         mutex_unlock(&dev_drv->fb_win_id_mutex);
1005
1006         printk("fb0:win%d\nfb1:win%d\nfb2:win%d\n",dev_drv->fb0_win_id,dev_drv->fb1_win_id,
1007                 dev_drv->fb2_win_id);
1008
1009         return 0;
1010 }
1011
1012 static int rk3066b_fb_get_layer(struct rk_lcdc_device_driver *dev_drv,const char *id)
1013 {
1014         int layer_id = 0;
1015         mutex_lock(&dev_drv->fb_win_id_mutex);
1016         if(!strcmp(id,"fb0") || !strcmp(id,"fb2"))
1017         {
1018                 layer_id = dev_drv->fb0_win_id;
1019         }
1020         else if(!strcmp(id,"fb1") || !strcmp(id,"fb3"))
1021         {
1022                 layer_id = dev_drv->fb1_win_id;
1023         }
1024         else
1025         {
1026                 printk(KERN_ERR "%s>>un supported %s\n",__func__,id);
1027                 layer_id = -1;
1028         }
1029         mutex_unlock(&dev_drv->fb_win_id_mutex);
1030
1031         return  layer_id;
1032 }
1033
1034
1035 static void rk3066b_lcdc_reg_dump(struct rk3066b_lcdc_device *lcdc_dev)
1036 {
1037         int *cbase =  (int *)lcdc_dev->reg_vir_base;
1038         int i,j;
1039
1040         for(i=0; i<=(0xa0>>4);i++)
1041         {
1042                 for(j=0;j<4;j++)
1043                         printk("%08x  ",readl(cbase+i*4 +j));
1044                 printk("\n");
1045         }
1046
1047 }
1048
1049 int rk3066b_lcdc_early_suspend(struct rk_lcdc_device_driver *dev_drv)
1050 {
1051         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
1052
1053         if(dev_drv->screen0->standby)
1054                 dev_drv->screen0->standby(1);
1055         if(dev_drv->screen_ctr_info->io_disable)
1056                 dev_drv->screen_ctr_info->io_disable();
1057
1058         spin_lock(&lcdc_dev->reg_lock);
1059         if(likely(lcdc_dev->clk_on))
1060         {
1061                 lcdc_dev->clk_on = 0;
1062                 LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_STARTCLEAR, v_FRM_STARTCLEAR(1));
1063                 LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(1));
1064                 LCDC_REG_CFG_DONE();
1065                 spin_unlock(&lcdc_dev->reg_lock);
1066         }
1067         else  //clk already disabled
1068         {
1069                 spin_unlock(&lcdc_dev->reg_lock);
1070                 return 0;
1071         }
1072
1073
1074         mdelay(30);
1075         clk_disable(lcdc_dev->dclk);
1076         clk_disable(lcdc_dev->hclk);
1077         clk_disable(lcdc_dev->aclk);
1078         clk_disable(lcdc_dev->pd);
1079
1080         return 0;
1081 }
1082
1083
1084 int rk3066b_lcdc_early_resume(struct rk_lcdc_device_driver *dev_drv)
1085 {
1086         struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
1087         int i=0;
1088         int __iomem *c;
1089         int v;
1090
1091         if(dev_drv->screen_ctr_info->io_enable)                 //power on
1092                 dev_drv->screen_ctr_info->io_enable();
1093
1094         if(!lcdc_dev->clk_on)
1095         {
1096                 clk_enable(lcdc_dev->pd);
1097                 clk_enable(lcdc_dev->hclk);
1098                 clk_enable(lcdc_dev->dclk);
1099                 clk_enable(lcdc_dev->aclk);
1100         }
1101         mdelay(5);
1102         memcpy((u8*)lcdc_dev->preg, (u8*)&lcdc_dev->regbak, 0x24);  //resume reg ,skip INT_STATUS reg
1103         memcpy(((u8*)lcdc_dev->preg) + 0x28,((u8*)&lcdc_dev->regbak) + 0x28, 0x74);
1104
1105         spin_lock(&lcdc_dev->reg_lock);
1106
1107         if(dev_drv->cur_screen->dsp_lut)                        //resume dsp lut
1108         {
1109                 LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(0));
1110                 LCDC_REG_CFG_DONE();
1111
1112                 mdelay(25); //wait for dsp lut disabled
1113                 for(i=0;i<256;i++)
1114                 {
1115                         v = dev_drv->cur_screen->dsp_lut[i];
1116                         c = lcdc_dev->dsp_lut_addr_base+i;
1117                         writel_relaxed(v,c);
1118                 }
1119                 LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(1));//enable dsp lut
1120         }
1121         if(lcdc_dev->atv_layer_cnt)
1122         {
1123                 LcdMskReg(lcdc_dev, SYS_CFG,m_LCDC_STANDBY,v_LCDC_STANDBY(0));
1124                 LcdMskReg(lcdc_dev, INT_STATUS, m_SCANNING_CLEAR | m_FRM_STARTCLEAR | m_HOR_STARTCLEAR |
1125                                         m_SCANNING_MASK | m_HOR_STARTMASK | m_FRM_STARTMASK ,
1126                                         v_SCANNING_CLEAR(1) | v_FRM_STARTCLEAR(1) | v_HOR_STARTCLEAR(1) |
1127                                         v_SCANNING_MASK(0) | v_FRM_STARTMASK(0) | v_HOR_STARTMASK(1));
1128                 LCDC_REG_CFG_DONE();
1129         }
1130         lcdc_dev->clk_on = 1;
1131         spin_unlock(&lcdc_dev->reg_lock);
1132
1133         if(!lcdc_dev->atv_layer_cnt)
1134                 rk3066b_lcdc_clk_disable(lcdc_dev);
1135
1136         if(dev_drv->screen0->standby)
1137                 dev_drv->screen0->standby(0);         //screen wake up
1138
1139         return 0;
1140 }
1141 static irqreturn_t rk3066b_lcdc_isr(int irq, void *dev_id)
1142 {
1143         struct rk3066b_lcdc_device *lcdc_dev = (struct rk3066b_lcdc_device *)dev_id;
1144
1145         u32 int_reg = LcdRdReg(lcdc_dev,INT_STATUS);
1146         if(int_reg & m_FRM_START){
1147         ktime_t timestamp = ktime_get();
1148
1149         LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_STARTCLEAR, v_FRM_STARTCLEAR(1));
1150
1151         //LcdMskReg(lcdc_dev, INT_STATUS, m_LINE_FLAG_INT_CLEAR, v_LINE_FLAG_INT_CLEAR(1));
1152
1153 #if 0
1154         if(lcdc_dev->driver.num_buf < 3)  //three buffer ,no need to wait for sync
1155         {
1156                 spin_lock(&(lcdc_dev->driver.cpl_lock));
1157                 complete(&(lcdc_dev->driver.frame_done));
1158                 spin_unlock(&(lcdc_dev->driver.cpl_lock));
1159         }
1160 #endif
1161
1162         lcdc_dev->driver.vsync_info.timestamp = timestamp;
1163         wake_up_interruptible_all(&lcdc_dev->driver.vsync_info.wait);
1164         }
1165         else if(int_reg & m_SCANNING_FLAG){
1166                 LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_STARTCLEAR, v_SCANNING_CLEAR(1));
1167         }
1168         return IRQ_HANDLED;
1169 }
1170
1171
1172 static int rk3066b_set_dsp_lut(struct rk_lcdc_device_driver *dev_drv,int *lut)
1173 {
1174         int i=0;
1175         int __iomem *c;
1176         int v;
1177         int ret = 0;
1178
1179         struct rk3066b_lcdc_device *lcdc_dev =
1180                                 container_of(dev_drv,struct rk3066b_lcdc_device,driver);
1181         LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(0));
1182         LCDC_REG_CFG_DONE();
1183         msleep(25);
1184         if(dev_drv->cur_screen->dsp_lut)
1185         {
1186                 for(i=0;i<256;i++)
1187                 {
1188                         v = dev_drv->cur_screen->dsp_lut[i] = lut[i];
1189                         c = lcdc_dev->dsp_lut_addr_base+i;
1190                         writel_relaxed(v,c);
1191                 }
1192         }
1193         else
1194         {
1195                 dev_err(dev_drv->dev,"no buffer to backup lut data!\n");
1196                 ret =  -1;
1197         }
1198         LcdMskReg(lcdc_dev,SYS_CFG,m_DSIP_LUT_CTL,v_DSIP_LUT_CTL(1));
1199         LCDC_REG_CFG_DONE();
1200
1201         return ret;
1202 }
1203
1204 int rk3066b_lcdc_poll_vblank(struct rk_lcdc_device_driver * dev_drv)
1205 {
1206         struct rk3066b_lcdc_device *lcdc_dev =
1207                                 container_of(dev_drv,struct rk3066b_lcdc_device,driver);
1208         u32 int_reg ;
1209         int ret;
1210         //spin_lock(&lcdc_dev->reg_lock);
1211         if(lcdc_dev->clk_on)
1212         {
1213                 int_reg = LcdRdReg(lcdc_dev,INT_STATUS);
1214                 if(int_reg & m_SCANNING_FLAG)
1215                 {
1216                       LcdMskReg(lcdc_dev, INT_STATUS, m_SCANNING_CLEAR,v_SCANNING_CLEAR(1));
1217                       ret =  RK_LF_STATUS_FC;
1218                 }
1219                 else
1220                      ret = RK_LF_STATUS_FR;
1221         }
1222         else
1223         {
1224                 ret = RK_LF_STATUS_NC;
1225         }
1226         //spin_unlock(&lcdc_dev->reg_lock);
1227
1228
1229         return ret;
1230 }
1231
1232 static struct layer_par lcdc_layer[] = {
1233         [0] = {
1234                 .name           = "win0",
1235                 .id             = 0,
1236                 .support_3d     = true,
1237         },
1238         [1] = {
1239                 .name           = "win1",
1240                 .id             = 1,
1241                 .support_3d     = false,
1242         },
1243 };
1244
1245 static struct rk_lcdc_device_driver lcdc_driver = {
1246         .name                   = "lcdc",
1247         .def_layer_par          = lcdc_layer,
1248         .num_layer              = ARRAY_SIZE(lcdc_layer),
1249         .open                   = rk3066b_lcdc_open,
1250         .init_lcdc              = init_rk3066b_lcdc,
1251         .ioctl                  = rk3066b_lcdc_ioctl,
1252         .suspend                = rk3066b_lcdc_early_suspend,
1253         .resume                 = rk3066b_lcdc_early_resume,
1254         .set_par                = rk3066b_lcdc_set_par,
1255         .blank                  = rk3066b_lcdc_blank,
1256         .pan_display            = rk3066b_lcdc_pan_display,
1257         .load_screen            = rk3066b_load_screen,
1258         .get_layer_state        = rk3066b_lcdc_get_layer_state,
1259         .ovl_mgr                = rk3066b_lcdc_ovl_mgr,
1260         .get_disp_info          = rk3066b_lcdc_get_disp_info,
1261         .fps_mgr                = rk3066b_lcdc_fps_mgr,
1262         .fb_get_layer           = rk3066b_fb_get_layer,
1263         .fb_layer_remap         = rk3066b_fb_layer_remap,
1264         .set_dsp_lut            = rk3066b_set_dsp_lut,
1265         .poll_vblank            = rk3066b_lcdc_poll_vblank,
1266 };
1267 #ifdef CONFIG_PM
1268 static int rk3066b_lcdc_suspend(struct platform_device *pdev, pm_message_t state)
1269 {
1270         return 0;
1271 }
1272
1273 static int rk3066b_lcdc_resume(struct platform_device *pdev)
1274 {
1275         return 0;
1276 }
1277
1278 #else
1279 #define rk3066b_lcdc_suspend NULL
1280 #define rk3066b_lcdc_resume NULL
1281 #endif
1282
1283 static int __devinit rk3066b_lcdc_probe (struct platform_device *pdev)
1284 {
1285         struct rk3066b_lcdc_device *lcdc_dev=NULL;
1286         rk_screen *screen;
1287         rk_screen *screen1;
1288         struct rk29fb_info *screen_ctr_info;
1289         struct resource *res = NULL;
1290         struct resource *mem;
1291         int ret = 0;
1292
1293         /*************Malloc rk3066blcdc_inf and set it to pdev for drvdata**********/
1294         lcdc_dev = kzalloc(sizeof(struct rk3066b_lcdc_device), GFP_KERNEL);
1295         if(!lcdc_dev)
1296         {
1297                 dev_err(&pdev->dev, ">>rk3066b lcdc device kmalloc fail!");
1298                 return -ENOMEM;
1299         }
1300         platform_set_drvdata(pdev, lcdc_dev);
1301         lcdc_dev->id = pdev->id;
1302         screen_ctr_info = (struct rk29fb_info * )pdev->dev.platform_data;
1303         screen =  kzalloc(sizeof(rk_screen), GFP_KERNEL);
1304         if(!screen)
1305         {
1306                 dev_err(&pdev->dev, ">>rk3066b lcdc screen kmalloc fail!");
1307                 ret =  -ENOMEM;
1308                 goto err0;
1309         }
1310         else
1311         {
1312                 lcdc_dev->screen = screen;
1313         }
1314         screen->lcdc_id = lcdc_dev->id;
1315         screen->screen_id = 0;
1316
1317 #if defined(CONFIG_ONE_LCDC_DUAL_OUTPUT_INF)&& (defined(CONFIG_RK610_LVDS) || defined(CONFIG_RK616_LVDS))
1318         screen1 =  kzalloc(sizeof(rk_screen), GFP_KERNEL);
1319         if(!screen1)
1320         {
1321                 dev_err(&pdev->dev, ">>rk3066b lcdc screen1 kmalloc fail!");
1322                 ret =  -ENOMEM;
1323                 goto err0;
1324         }
1325         screen1->lcdc_id = 1;
1326         screen1->screen_id = 1;
1327         printk("use lcdc%d and rk610 implemention dual display!\n",lcdc_dev->id);
1328
1329 #endif
1330         /****************get lcdc0 reg  *************************/
1331         res = platform_get_resource(pdev, IORESOURCE_MEM,0);
1332         if (res == NULL)
1333         {
1334                 dev_err(&pdev->dev, "failed to get io resource for lcdc%d \n",lcdc_dev->id);
1335                 ret = -ENOENT;
1336                 goto err1;
1337         }
1338         lcdc_dev->reg_phy_base = res->start;
1339         lcdc_dev->len = resource_size(res);
1340         mem = request_mem_region(lcdc_dev->reg_phy_base, resource_size(res), pdev->name);
1341         if (mem == NULL)
1342         {
1343                 dev_err(&pdev->dev, "failed to request mem region for lcdc%d\n",lcdc_dev->id);
1344                 ret = -ENOENT;
1345                 goto err1;
1346         }
1347         lcdc_dev->reg_vir_base = ioremap(lcdc_dev->reg_phy_base,  resource_size(res));
1348         if (lcdc_dev->reg_vir_base == NULL)
1349         {
1350                 dev_err(&pdev->dev, "cannot map IO\n");
1351                 ret = -ENXIO;
1352                 goto err2;
1353         }
1354
1355         lcdc_dev->preg = (LCDC_REG*)lcdc_dev->reg_vir_base;
1356         printk("lcdc%d:reg_phy_base = 0x%08x,reg_vir_base:0x%p\n",pdev->id,lcdc_dev->reg_phy_base, lcdc_dev->preg);
1357         lcdc_dev->dsp_lut_addr_base = (lcdc_dev->reg_vir_base+DSP_LUT_ADDR);
1358
1359         lcdc_dev->driver.dev=&pdev->dev;
1360         lcdc_dev->driver.screen0 = screen;
1361 #if defined(CONFIG_ONE_LCDC_DUAL_OUTPUT_INF)&& (defined(CONFIG_RK610_LVDS) || defined(CONFIG_RK616_LVDS))
1362         lcdc_dev->driver.screen1 = screen1;
1363 #endif
1364         lcdc_dev->driver.cur_screen = screen;
1365         lcdc_dev->driver.screen_ctr_info = screen_ctr_info;
1366         spin_lock_init(&lcdc_dev->reg_lock);
1367         lcdc_dev->irq = platform_get_irq(pdev, 0);
1368         if(lcdc_dev->irq < 0)
1369         {
1370                 dev_err(&pdev->dev, "cannot find IRQ\n");
1371                 goto err3;
1372         }
1373         ret = request_irq(lcdc_dev->irq, rk3066b_lcdc_isr, IRQF_DISABLED,dev_name(&pdev->dev),lcdc_dev);
1374         if (ret)
1375         {
1376                dev_err(&pdev->dev, "cannot requeset irq %d - err %d\n", lcdc_dev->irq, ret);
1377                ret = -EBUSY;
1378                goto err3;
1379         }
1380
1381         if(screen_ctr_info->set_screen_info)
1382         {
1383                 screen_ctr_info->set_screen_info(screen,screen_ctr_info->lcd_info);
1384                 if(SCREEN_NULL==screen->type)
1385                 {
1386                         printk(KERN_WARNING "no display device on lcdc%d!?\n",lcdc_dev->id);
1387                         ret = -ENODEV;
1388                 }
1389                 if(screen_ctr_info->io_init)
1390                         screen_ctr_info->io_init(NULL);
1391         }
1392         else
1393         {
1394                 printk(KERN_WARNING "no display device on lcdc%d!?\n",lcdc_dev->id);
1395                 ret =  -ENODEV;
1396                 goto err4;
1397         }
1398
1399         ret = rk_fb_register(&(lcdc_dev->driver),&lcdc_driver,lcdc_dev->id);
1400         if(ret < 0)
1401         {
1402                 printk(KERN_ERR "register fb for lcdc%d failed!\n",lcdc_dev->id);
1403                 goto err4;
1404         }
1405         printk("rk3066b lcdc%d probe ok!\n",lcdc_dev->id);
1406
1407         return 0;
1408
1409 err4:
1410         free_irq(lcdc_dev->irq,lcdc_dev);
1411 err3:
1412         iounmap(lcdc_dev->reg_vir_base);
1413 err2:
1414         release_mem_region(lcdc_dev->reg_phy_base,resource_size(res));
1415 err1:
1416         kfree(screen);
1417 err0:
1418         platform_set_drvdata(pdev, NULL);
1419         kfree(lcdc_dev);
1420         return ret;
1421
1422 }
1423 static int __devexit rk3066b_lcdc_remove(struct platform_device *pdev)
1424 {
1425         struct rk3066b_lcdc_device *lcdc_dev = platform_get_drvdata(pdev);
1426         rk_fb_unregister(&(lcdc_dev->driver));
1427         rk3066b_lcdc_deinit(lcdc_dev);
1428         iounmap(lcdc_dev->reg_vir_base);
1429         release_mem_region(lcdc_dev->reg_phy_base,lcdc_dev->len);
1430         kfree(lcdc_dev->screen);
1431         kfree(lcdc_dev);
1432         return 0;
1433 }
1434
1435 static void rk3066b_lcdc_shutdown(struct platform_device *pdev)
1436 {
1437         struct rk3066b_lcdc_device *lcdc_dev = platform_get_drvdata(pdev);
1438         if(lcdc_dev->driver.cur_screen->standby) //standby the screen if necessary
1439                 lcdc_dev->driver.cur_screen->standby(1);
1440         if(lcdc_dev->driver.screen_ctr_info->io_disable) //power off the screen if necessary
1441                 lcdc_dev->driver.screen_ctr_info->io_disable();
1442         if(lcdc_dev->driver.cur_screen->sscreen_set) //turn off  lvds if necessary
1443                 lcdc_dev->driver.cur_screen->sscreen_set(lcdc_dev->driver.cur_screen , 0);
1444
1445         rk3066b_lcdc_deinit(lcdc_dev);
1446         rk_fb_unregister(&(lcdc_dev->driver));
1447
1448         /*iounmap(lcdc_dev->reg_vir_base);
1449         release_mem_region(lcdc_dev->reg_phy_base,lcdc_dev->len);
1450         kfree(lcdc_dev->screen);
1451         kfree(lcdc_dev);*/
1452 }
1453
1454
1455 static struct platform_driver rk3066b_lcdc_driver = {
1456         .probe          = rk3066b_lcdc_probe,
1457         .remove         = __devexit_p(rk3066b_lcdc_remove),
1458         .driver         = {
1459                 .name   = "rk30-lcdc",
1460                 .owner  = THIS_MODULE,
1461         },
1462         .suspend        = rk3066b_lcdc_suspend,
1463         .resume         = rk3066b_lcdc_resume,
1464         .shutdown       = rk3066b_lcdc_shutdown,
1465 };
1466
1467 static int __init rk3066b_lcdc_init(void)
1468 {
1469         return platform_driver_register(&rk3066b_lcdc_driver);
1470 }
1471
1472 static void __exit rk3066b_lcdc_exit(void)
1473 {
1474         platform_driver_unregister(&rk3066b_lcdc_driver);
1475 }
1476
1477
1478
1479 fs_initcall(rk3066b_lcdc_init);
1480 module_exit(rk3066b_lcdc_exit);
1481
1482
1483