drivers/video/rockchip/lcdc/rk2928_lcdc.c

   1 /*
   2  * drivers/video/rockchip/chips/rk2928_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 #include <mach/gpio.h>
  35 #include "rk2928_lcdc.h"
  36 #include "../transmitter/rk2928_lvds.h"
  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
  48 //rk2928 lcdc iomux,mode:0,gpio,1 lcdc io
  49 static int rk2928_lcdc_iomux(rk_screen *screen,int mode)
  50 {
  51         int ret = 0;
  52         int i=0;
  53         if((screen->type == SCREEN_RGB)&&(mode)) //iomux for RGB screen
  54         {
  55                 for(i=0;i<8;i++)
  56                 {
  57                         gpio_free(RK2928_PIN2_PB0 + i);
  58                 }
  59                 for(i=0;i<4;i++)
  60                 {
  61                         gpio_free(RK2928_PIN2_PC0 + i);
  62                 }
  63
  64                 if(screen->lcdc_id == 0)
  65                 {
  66                         rk30_mux_api_set(GPIO2B0_LCDC0_DCLK_LCDC1_DCLK_NAME, GPIO2B_LCDC0_DCLK);
  67                         rk30_mux_api_set(GPIO2B1_LCDC0_HSYNC_LCDC1_HSYNC_NAME, GPIO2B_LCDC0_HSYNC);
  68                         rk30_mux_api_set(GPIO2B2_LCDC0_VSYNC_LCDC1_VSYNC_NAME, GPIO2B_LCDC0_VSYNC);
  69                         rk30_mux_api_set(GPIO2B3_LCDC0_DEN_LCDC1_DEN_NAME, GPIO2B_LCDC0_DEN);
  70                         rk30_mux_api_set(GPIO2B4_LCDC0_D10_LCDC1_D10_NAME, GPIO2B_LCDC0_D10);
  71                         rk30_mux_api_set(GPIO2B5_LCDC0_D11_LCDC1_D11_NAME, GPIO2B_LCDC0_D11);
  72                         rk30_mux_api_set(GPIO2B6_LCDC0_D12_LCDC1_D12_NAME, GPIO2B_LCDC0_D12);
  73                         rk30_mux_api_set(GPIO2B7_LCDC0_D13_LCDC1_D13_NAME, GPIO2B_LCDC0_D13);
  74                         rk30_mux_api_set(GPIO2C0_LCDC0_D14_LCDC1_D14_NAME, GPIO2C_LCDC0_D14);
  75                         rk30_mux_api_set(GPIO2C1_LCDC0_D15_LCDC1_D15_NAME, GPIO2C_LCDC0_D15);
  76                         rk30_mux_api_set(GPIO2C2_LCDC0_D16_LCDC1_D16_NAME, GPIO2C_LCDC0_D16);
  77                         rk30_mux_api_set(GPIO2C3_LCDC0_D17_LCDC1_D17_NAME, GPIO2C_LCDC0_D17);
  78                 }
  79                 else if(screen->lcdc_id == 1)
  80                 {
  81                         rk30_mux_api_set(GPIO2B0_LCDC0_DCLK_LCDC1_DCLK_NAME, GPIO2B_LCDC1_DCLK);
  82                         rk30_mux_api_set(GPIO2B1_LCDC0_HSYNC_LCDC1_HSYNC_NAME, GPIO2B_LCDC1_HSYNC);
  83                         rk30_mux_api_set(GPIO2B2_LCDC0_VSYNC_LCDC1_VSYNC_NAME, GPIO2B_LCDC1_VSYNC);
  84                         rk30_mux_api_set(GPIO2B3_LCDC0_DEN_LCDC1_DEN_NAME, GPIO2B_LCDC1_DEN);
  85                         rk30_mux_api_set(GPIO2B4_LCDC0_D10_LCDC1_D10_NAME, GPIO2B_LCDC1_D10);
  86                         rk30_mux_api_set(GPIO2B5_LCDC0_D11_LCDC1_D11_NAME, GPIO2B_LCDC1_D11);
  87                         rk30_mux_api_set(GPIO2B6_LCDC0_D12_LCDC1_D12_NAME, GPIO2B_LCDC1_D12);
  88                         rk30_mux_api_set(GPIO2B7_LCDC0_D13_LCDC1_D13_NAME, GPIO2B_LCDC1_D13);
  89                         rk30_mux_api_set(GPIO2C0_LCDC0_D14_LCDC1_D14_NAME, GPIO2C_LCDC1_D14);
  90                         rk30_mux_api_set(GPIO2C1_LCDC0_D15_LCDC1_D15_NAME, GPIO2C_LCDC1_D15);
  91                         rk30_mux_api_set(GPIO2C2_LCDC0_D16_LCDC1_D16_NAME, GPIO2C_LCDC1_D16);
  92                         rk30_mux_api_set(GPIO2C3_LCDC0_D17_LCDC1_D17_NAME, GPIO2C_LCDC1_D17);
  93                 }
  94                 else
  95                 {
  96                         printk(KERN_WARNING "%s>>>no such interface:%d\n",__func__,screen->lcdc_id);
  97                         return -1;
  98                 }
  99         }
 100         else if((screen->type == SCREEN_RGB)&&(!mode))
 101         {
 102                 rk30_mux_api_set(GPIO2B0_LCDC0_DCLK_LCDC1_DCLK_NAME, GPIO2B_GPIO2B0 );
 103                 rk30_mux_api_set(GPIO2B1_LCDC0_HSYNC_LCDC1_HSYNC_NAME,GPIO2B_GPIO2B1);
 104                 rk30_mux_api_set(GPIO2B2_LCDC0_VSYNC_LCDC1_VSYNC_NAME,  GPIO2B_GPIO2B2);
 105                 rk30_mux_api_set(GPIO2B3_LCDC0_DEN_LCDC1_DEN_NAME, GPIO2B_GPIO2B3);
 106                 rk30_mux_api_set(GPIO2B4_LCDC0_D10_LCDC1_D10_NAME, GPIO2B_GPIO2B4 );
 107                 rk30_mux_api_set(GPIO2B5_LCDC0_D11_LCDC1_D11_NAME, GPIO2B_GPIO2B5 );
 108                 rk30_mux_api_set(GPIO2B6_LCDC0_D12_LCDC1_D12_NAME, GPIO2B_GPIO2B6 );
 109                 rk30_mux_api_set(GPIO2B7_LCDC0_D13_LCDC1_D13_NAME, GPIO2B_GPIO2B7 );
 110                 rk30_mux_api_set(GPIO2C0_LCDC0_D14_LCDC1_D14_NAME, GPIO2C_GPIO2C0);
 111                 rk30_mux_api_set(GPIO2C1_LCDC0_D15_LCDC1_D15_NAME, GPIO2C_GPIO2C1);
 112                 rk30_mux_api_set(GPIO2C2_LCDC0_D16_LCDC1_D16_NAME, GPIO2C_GPIO2C2);
 113                 rk30_mux_api_set(GPIO2C3_LCDC0_D17_LCDC1_D17_NAME, GPIO2C_GPIO2C3);
 114                 for(i=0;i<8;i++)
 115                 {
 116                         ret += gpio_request(RK2928_PIN2_PB0 + i, NULL);
 117                         gpio_direction_output(RK2928_PIN2_PB0 + i, 0);
 118                 }
 119                 for(i=0;i<4;i++)
 120                 {
 121                         ret += gpio_request(RK2928_PIN2_PC0 + i, NULL);
 122                         gpio_direction_output(RK2928_PIN2_PC0 + i, 0);
 123                 }
 124                 if(ret < 0)
 125                 {
 126                         printk("%s:some gpio request fail\n",__func__);
 127                 }
 128         }
 129         return 0;
 130 }
 131 static int init_rk2928_lcdc(struct rk_lcdc_device_driver *dev_drv)
 132 {
 133         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 134         if(lcdc_dev->id == 0) //lcdc0
 135         {
 136                 lcdc_dev->hclk = clk_get(NULL,"hclk_lcdc0");
 137                 lcdc_dev->aclk = clk_get(NULL,"aclk_lcdc0");
 138                 lcdc_dev->dclk = clk_get(NULL,"dclk_lcdc0");
 139                 lcdc_dev->sclk = clk_get(NULL,"sclk_lcdc0");
 140         }
 141         else
 142         {
 143                 printk(KERN_ERR "invalid lcdc device!\n");
 144                 return -EINVAL;
 145         }
 146         if (IS_ERR(lcdc_dev->sclk) || (IS_ERR(lcdc_dev->aclk)) ||(IS_ERR(lcdc_dev->dclk)) || (IS_ERR(lcdc_dev->hclk)))
 147         {
 148                 printk(KERN_ERR "failed to get lcdc%d clk source\n",lcdc_dev->id);
 149         }
 150
 151         clk_enable(lcdc_dev->pd);
 152         clk_enable(lcdc_dev->hclk);  //enable aclk and hclk for register config
 153         clk_enable(lcdc_dev->aclk);
 154         lcdc_dev->clk_on = 1;
 155         LcdSetBit(lcdc_dev,SYS_CFG, m_LCDC_AXICLK_AUTO_ENABLE);//eanble axi-clk auto gating for low power
 156         LcdMskReg(lcdc_dev,INT_STATUS,m_FRM_START_INT_CLEAR | m_BUS_ERR_INT_CLEAR | m_LINE_FLAG_INT_EN |
 157               m_FRM_START_INT_EN | m_HOR_START_INT_EN,v_FRM_START_INT_CLEAR(1) | v_BUS_ERR_INT_CLEAR(0) |
 158               v_LINE_FLAG_INT_EN(0) | v_FRM_START_INT_EN(0) | v_HOR_START_INT_EN(0));  //enable frame start interrupt for sync
 159         //LCDC_REG_CFG_DONE();  // write any value to  REG_CFG_DONE let config become effective
 160         return 0;
 161 }
 162
 163 static int rk2928_lcdc_deinit(struct rk2928_lcdc_device *lcdc_dev)
 164 {
 165         spin_lock(&lcdc_dev->reg_lock);
 166         if(likely(lcdc_dev->clk_on))
 167         {
 168                 lcdc_dev->clk_on = 0;
 169                 LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_START_INT_CLEAR, v_FRM_START_INT_CLEAR(1));
 170                 LcdMskReg(lcdc_dev, INT_STATUS, m_HOR_START_INT_EN | m_FRM_START_INT_EN |
 171                         m_LINE_FLAG_INT_EN | m_BUS_ERR_INT_EN,v_HOR_START_INT_EN(0) | v_FRM_START_INT_EN(0) |
 172                         v_LINE_FLAG_INT_EN(0) | v_BUS_ERR_INT_EN(0));  //disable all lcdc interrupt
 173                 LcdSetBit(lcdc_dev,SYS_CFG,m_LCDC_STANDBY);
 174                 LCDC_REG_CFG_DONE();
 175                 spin_unlock(&lcdc_dev->reg_lock);
 176         }
 177         else   //clk already disabled
 178         {
 179                 spin_unlock(&lcdc_dev->reg_lock);
 180                 return 0;
 181         }
 182         mdelay(1);
 183
 184         return 0;
 185 }
 186
 187 static int rk2928_load_screen(struct rk_lcdc_device_driver *dev_drv, bool initscreen)
 188 {
 189         int ret = -EINVAL;
 190         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 191         rk_screen *screen = dev_drv->cur_screen;
 192         rk_screen *screen0 = dev_drv->screen0;
 193         u64 ft;
 194         int fps;
 195         u16 face;
 196         u16 right_margin = screen->right_margin;
 197         u16 lower_margin = screen->lower_margin;
 198         u16 x_res = screen->x_res, y_res = screen->y_res;
 199         DBG(1,"left_margin:%d>>hsync_len:%d>>xres:%d>>right_margin:%d>>upper_margin:%d>>vsync_len:%d>>yres:%d>>lower_margin:%d\n",
 200                 screen->left_margin,screen->hsync_len,screen->x_res,screen->right_margin,screen->upper_margin,screen->vsync_len,screen->y_res,
 201                 screen->lower_margin);
 202         // set the rgb or mcu
 203         spin_lock(&lcdc_dev->reg_lock);
 204         if(likely(lcdc_dev->clk_on))
 205         {
 206                 if(screen->type==SCREEN_MCU)
 207                 {
 208                         printk(KERN_ERR "MCU Screen is not supported by RK2928\n");
 209
 210                 }
 211
 212                 switch (screen->face)
 213                 {
 214                         case OUT_P565:
 215                                 face = OUT_P565;
 216                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
 217                                 break;
 218                         case OUT_P666:
 219                                 face = OUT_P666;
 220                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
 221                                 break;
 222                         case OUT_D888_P565:
 223                                 face = OUT_P888;
 224                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
 225                                 break;
 226                         case OUT_D888_P666:
 227                                 face = OUT_P888;
 228                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
 229                                 break;
 230                         case OUT_P888:
 231                                 face = OUT_P888;
 232                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_UP_EN, v_DITHER_UP_EN(0));
 233                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(0) | v_DITHER_DOWN_MODE(0));
 234                                 break;
 235                         default:
 236                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_UP_EN, v_DITHER_UP_EN(0));
 237                                 LcdMskReg(lcdc_dev, DSP_CTRL, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(0) | v_DITHER_DOWN_MODE(0));
 238                                 face = screen->face;
 239                                 break;
 240                 }
 241
 242                 //use default overlay,set vsyn hsync den dclk polarity
 243                 LcdMskReg(lcdc_dev, DSP_CTRL,m_DISPLAY_FORMAT | m_HSYNC_POLARITY | m_VSYNC_POLARITY |
 244                         m_DEN_POLARITY |m_DCLK_POLARITY | m_OUTPUT_RB_SWAP | m_OUTPUT_RG_SWAP | m_BLACK_MODE,
 245                         v_DISPLAY_FORMAT(face) | v_HSYNC_POLARITY(screen->pin_hsync) |
 246                         v_VSYNC_POLARITY(screen->pin_vsync) | v_DEN_POLARITY(screen->pin_den) |
 247                         v_DCLK_POLARITY(screen->pin_dclk) | v_OUTPUT_RB_SWAP(screen->swap_rb) |
 248                         v_OUTPUT_RG_SWAP(screen->swap_rg) |v_BLACK_MODE(0));
 249
 250                 //set background color to black,set swap according to the screen panel,disable blank mode
 251                 LcdMskReg(lcdc_dev, BG_COLOR, m_BG_COLOR ,v_BG_COLOR(0x000000));
 252
 253
 254                 LcdWrReg(lcdc_dev, DSP_HTOTAL_HS_END,v_HSYNC(screen->hsync_len) |
 255                      v_HORPRD(screen->hsync_len + screen->left_margin + x_res + right_margin));
 256                 LcdWrReg(lcdc_dev, DSP_HACT_ST_END, v_HAEP(screen->hsync_len + screen->left_margin + x_res) |
 257                      v_HASP(screen->hsync_len + screen->left_margin));
 258
 259                 LcdWrReg(lcdc_dev, DSP_VTOTAL_VS_END, v_VSYNC(screen->vsync_len) |
 260                       v_VERPRD(screen->vsync_len + screen->upper_margin + y_res + lower_margin));
 261                 LcdWrReg(lcdc_dev, DSP_VACT_ST_END,  v_VAEP(screen->vsync_len + screen->upper_margin+y_res)|
 262                       v_VASP(screen->vsync_len + screen->upper_margin));
 263
 264 #if defined(CONFIG_ONE_LCDC_DUAL_OUTPUT_INF)
 265          if(dev_drv->screen0->lcdc_id == 1)
 266          {
 267                 //set register for scaller
 268                 LcdMskReg(lcdc_dev,SCL_REG0,m_SCL_DSP_ZERO | m_SCL_DEN_INVERT |
 269                         m_SCL_SYNC_INVERT | m_SCL_DCLK_INVERT | m_SCL_EN,v_SCL_DSP_ZERO(0) |
 270                         v_SCL_DEN_INVERT(screen0->s_den_inv) | v_SCL_SYNC_INVERT(screen0->s_hv_sync_inv) |
 271                         v_SCL_DCLK_INVERT(screen0->s_clk_inv) | v_SCL_EN(1));
 272                 LcdWrReg(lcdc_dev,SCL_REG2,v_HASP(screen0->s_vsync_st) | v_HAEP(screen0->s_hsync_st));
 273                 LcdWrReg(lcdc_dev,SCL_REG3,v_HASP(screen0->s_hsync_len) |
 274                          v_HAEP(screen0->s_hsync_len + screen0->s_left_margin +
 275                          screen0->x_res + screen0->s_right_margin));
 276                 LcdWrReg(lcdc_dev,SCL_REG4,v_HASP(screen0->s_hsync_len + screen0->s_left_margin) |
 277                          v_HAEP(screen0->s_hsync_len + screen0->s_left_margin + screen0->x_res));
 278                 LcdWrReg(lcdc_dev,SCL_REG5,v_VASP(screen0->s_vsync_len) |
 279                          v_VAEP(screen0->s_vsync_len + screen0->s_upper_margin +
 280                          screen0->y_res + screen0->s_lower_margin));
 281                 LcdWrReg(lcdc_dev,SCL_REG6,v_VASP(screen0->s_vsync_len +
 282                          screen0->s_upper_margin) | v_VAEP(screen0->s_vsync_len +
 283                          screen0->s_upper_margin + screen0->y_res ));
 284                 LcdWrReg(lcdc_dev,SCL_REG8,v_VASP(screen0->s_vsync_len + screen0->s_upper_margin) |
 285                          v_VAEP(screen0->s_vsync_len + screen0->s_upper_margin + screen0->y_res));
 286                 LcdWrReg(lcdc_dev,SCL_REG7,v_HASP(screen0->s_hsync_len + screen0->s_left_margin) |
 287                          v_HAEP(screen0->s_hsync_len + screen0->s_left_margin + screen0->x_res ));
 288                 LcdWrReg(lcdc_dev,SCL_REG1,v_SCL_V_FACTOR(0x1000)|v_SCL_H_FACTOR(0x1000));
 289          }
 290 #endif
 291                 // let above to take effect
 292                 //LCDC_REG_CFG_DONE();
 293         }
 294         spin_unlock(&lcdc_dev->reg_lock);
 295
 296 #ifdef CONFIG_RK2928_LVDS
 297         rk_lvds_register(dev_drv->screen0);
 298 #endif
 299         if(dev_drv->screen0->type == SCREEN_RGB) //iomux for RGB screen
 300         {
 301
 302                 if(dev_drv->screen0->lcdc_id == 0)
 303                 {
 304                         rk30_mux_api_set(GPIO2B0_LCDC0_DCLK_LCDC1_DCLK_NAME, GPIO2B_LCDC0_DCLK);
 305                         rk30_mux_api_set(GPIO2B1_LCDC0_HSYNC_LCDC1_HSYNC_NAME, GPIO2B_LCDC0_HSYNC);
 306                         rk30_mux_api_set(GPIO2B2_LCDC0_VSYNC_LCDC1_VSYNC_NAME, GPIO2B_LCDC0_VSYNC);
 307                         rk30_mux_api_set(GPIO2B3_LCDC0_DEN_LCDC1_DEN_NAME, GPIO2B_LCDC0_DEN);
 308                         rk30_mux_api_set(GPIO2B4_LCDC0_D10_LCDC1_D10_NAME, GPIO2B_LCDC0_D10);
 309                         rk30_mux_api_set(GPIO2B5_LCDC0_D11_LCDC1_D11_NAME, GPIO2B_LCDC0_D11);
 310                         rk30_mux_api_set(GPIO2B6_LCDC0_D12_LCDC1_D12_NAME, GPIO2B_LCDC0_D12);
 311                         rk30_mux_api_set(GPIO2B7_LCDC0_D13_LCDC1_D13_NAME, GPIO2B_LCDC0_D13);
 312                         rk30_mux_api_set(GPIO2C0_LCDC0_D14_LCDC1_D14_NAME, GPIO2C_LCDC0_D14);
 313                         rk30_mux_api_set(GPIO2C1_LCDC0_D15_LCDC1_D15_NAME, GPIO2C_LCDC0_D15);
 314                         rk30_mux_api_set(GPIO2C2_LCDC0_D16_LCDC1_D16_NAME, GPIO2C_LCDC0_D16);
 315                         rk30_mux_api_set(GPIO2C3_LCDC0_D17_LCDC1_D17_NAME, GPIO2C_LCDC0_D17);
 316                 }
 317                 else if(dev_drv->screen0->lcdc_id == 1)
 318                 {
 319                         rk30_mux_api_set(GPIO2B0_LCDC0_DCLK_LCDC1_DCLK_NAME, GPIO2B_LCDC1_DCLK);
 320                         rk30_mux_api_set(GPIO2B1_LCDC0_HSYNC_LCDC1_HSYNC_NAME, GPIO2B_LCDC1_HSYNC);
 321                         rk30_mux_api_set(GPIO2B2_LCDC0_VSYNC_LCDC1_VSYNC_NAME, GPIO2B_LCDC1_VSYNC);
 322                         rk30_mux_api_set(GPIO2B3_LCDC0_DEN_LCDC1_DEN_NAME, GPIO2B_LCDC1_DEN);
 323                         rk30_mux_api_set(GPIO2B4_LCDC0_D10_LCDC1_D10_NAME, GPIO2B_LCDC1_D10);
 324                         rk30_mux_api_set(GPIO2B5_LCDC0_D11_LCDC1_D11_NAME, GPIO2B_LCDC1_D11);
 325                         rk30_mux_api_set(GPIO2B6_LCDC0_D12_LCDC1_D12_NAME, GPIO2B_LCDC1_D12);
 326                         rk30_mux_api_set(GPIO2B7_LCDC0_D13_LCDC1_D13_NAME, GPIO2B_LCDC1_D13);
 327                         rk30_mux_api_set(GPIO2C0_LCDC0_D14_LCDC1_D14_NAME, GPIO2C_LCDC1_D14);
 328                         rk30_mux_api_set(GPIO2C1_LCDC0_D15_LCDC1_D15_NAME, GPIO2C_LCDC1_D15);
 329                         rk30_mux_api_set(GPIO2C2_LCDC0_D16_LCDC1_D16_NAME, GPIO2C_LCDC1_D16);
 330                         rk30_mux_api_set(GPIO2C3_LCDC0_D17_LCDC1_D17_NAME, GPIO2C_LCDC1_D17);
 331                 }
 332                 else
 333                 {
 334                         printk(KERN_WARNING "%s>>>no such interface:%d\n",__func__,dev_drv->cur_screen->lcdc_id);
 335                         return -1;
 336                 }
 337
 338                 //rk30_mux_api_set(GPIO2C4_LCDC0_D18_LCDC1_D18_I2C2_SDA_NAME, GPIO2C_LCDC1_D18);
 339                 //rk30_mux_api_set(GPIO2C5_LCDC0_D19_LCDC1_D19_I2C2_SCL_NAME, GPIO2C_LCDC1_D19);
 340                 //rk30_mux_api_set(GPIO2C6_LCDC0_D20_LCDC1_D20_UART2_SIN_NAME, GPIO2C_LCDC1_D20);
 341                 //rk30_mux_api_set(GPIO2C7_LCDC0_D21_LCDC1_D21_UART2_SOUT_NAME, GPIO2C_LCDC1_D21);
 342                 //rk30_mux_api_set(GPIO2D0_LCDC0_D22_LCDC1_D22_NAME, GPIO2D_LCDC1_D22);
 343                 //rk30_mux_api_set(GPIO2D1_LCDC0_D23_LCDC1_D23_NAME, GPIO2D_LCDC1_D23);
 344                 printk("RGB screen connect to rk2928 lcdc interface%d\n",dev_drv->screen0->lcdc_id);
 345
 346         }
 347
 348         ret = clk_set_rate(lcdc_dev->dclk, screen->pixclock);
 349         if(ret)
 350         {
 351                 printk(KERN_ERR ">>>>>> set lcdc%d dclk failed\n",lcdc_dev->id);
 352         }
 353         lcdc_dev->driver.pixclock = lcdc_dev->pixclock = div_u64(1000000000000llu, clk_get_rate(lcdc_dev->dclk));
 354         clk_enable(lcdc_dev->dclk);
 355 #if  defined(CONFIG_ONE_LCDC_DUAL_OUTPUT_INF)
 356
 357         if(dev_drv->screen0->lcdc_id == 1)  //if connect to output interface 1,need scale
 358         {
 359                 ret = clk_set_rate(lcdc_dev->sclk, screen0->s_pixclock);
 360                 if(ret)
 361                 {
 362                         printk(KERN_ERR ">>>>>> set lcdc%d sclk failed\n",lcdc_dev->id);
 363                 }
 364                 //lcdc_dev->driver.pixclock = lcdc_dev->pixclock = div_u64(1000000000000llu, clk_get_rate(lcdc_dev->sclk));
 365                 //printk("%s: sclk:%lu>>need:%d",lcdc_dev->driver.name,,screen0->s_pixclock);
 366                 clk_enable(lcdc_dev->sclk);
 367         }
 368 #endif
 369         ft = (u64)(screen->upper_margin + screen->lower_margin + screen->y_res +screen->vsync_len)*
 370                 (screen->left_margin + screen->right_margin + screen->x_res + screen->hsync_len)*
 371                 (dev_drv->pixclock);       // one frame time ,(pico seconds)
 372         fps = div64_u64(1000000000000llu,ft);
 373         screen->ft = 1000/fps;
 374         printk("%s: dclk:%lu>>fps:%d ",lcdc_dev->driver.name,clk_get_rate(lcdc_dev->dclk),
 375                 fps);
 376
 377         if(screen->init)
 378         {
 379                 screen->init();
 380         }
 381
 382         printk("%s for lcdc%d ok!\n",__func__,lcdc_dev->id);
 383         return 0;
 384 }
 385
 386
 387 //enable layer,open:1,enable;0 disable
 388 static int win0_open(struct rk2928_lcdc_device *lcdc_dev,bool open)
 389 {
 390
 391         spin_lock(&lcdc_dev->reg_lock);
 392         if(likely(lcdc_dev->clk_on))
 393         {
 394                 if(open)
 395                 {
 396                         if(!lcdc_dev->atv_layer_cnt)
 397                         {
 398                                 LcdClrBit(lcdc_dev, SYS_CFG,m_LCDC_STANDBY);
 399                         }
 400                         lcdc_dev->atv_layer_cnt++;
 401                 }
 402                 else
 403                 {
 404                         lcdc_dev->atv_layer_cnt--;
 405                 }
 406                 lcdc_dev->driver.layer_par[0]->state = open;
 407
 408                 LcdMskReg(lcdc_dev, SYS_CFG, m_W0_EN, v_W0_EN(open));
 409                 if(!lcdc_dev->atv_layer_cnt)  //if no layer used,disable lcdc
 410                 {
 411                         LcdSetBit(lcdc_dev, SYS_CFG,m_LCDC_STANDBY);
 412                 }
 413                 //LCDC_REG_CFG_DONE();
 414         }
 415         spin_unlock(&lcdc_dev->reg_lock);
 416         printk(KERN_INFO "lcdc%d win0 %s\n",lcdc_dev->id,open?"open":"closed");
 417         return 0;
 418 }
 419 static int win1_open(struct rk2928_lcdc_device *lcdc_dev,bool open)
 420 {
 421         spin_lock(&lcdc_dev->reg_lock);
 422         if(likely(lcdc_dev->clk_on))
 423         {
 424                 if(open)
 425                 {
 426                         if(!lcdc_dev->atv_layer_cnt)
 427                         {
 428                                 printk("lcdc%d wakeup from stanby\n",lcdc_dev->id);
 429                                 LcdClrBit(lcdc_dev, SYS_CFG,m_LCDC_STANDBY);
 430                         }
 431                         lcdc_dev->atv_layer_cnt++;
 432                 }
 433                 else
 434                 {
 435                         lcdc_dev->atv_layer_cnt--;
 436                 }
 437                 lcdc_dev->driver.layer_par[1]->state = open;
 438
 439                 LcdMskReg(lcdc_dev, SYS_CFG, m_W1_EN, v_W1_EN(open));
 440                 if(!lcdc_dev->atv_layer_cnt)  //if no layer used,disable lcdc
 441                 {
 442                         printk(KERN_INFO "no layer of lcdc%d is used,go to standby!",lcdc_dev->id);
 443                         LcdSetBit(lcdc_dev, SYS_CFG,m_LCDC_STANDBY);
 444                 }
 445                 //LCDC_REG_CFG_DONE();
 446         }
 447         spin_unlock(&lcdc_dev->reg_lock);
 448         printk(KERN_INFO "lcdc%d win1 %s\n",lcdc_dev->id,open?"open":"closed");
 449         return 0;
 450 }
 451
 452
 453 static int rk2928_lcdc_blank(struct rk_lcdc_device_driver*lcdc_drv,int layer_id,int blank_mode)
 454 {
 455         struct rk2928_lcdc_device * lcdc_dev = container_of(lcdc_drv,struct rk2928_lcdc_device ,driver);
 456
 457         printk(KERN_INFO "%s>>>>>%d\n",__func__, blank_mode);
 458
 459         spin_lock(&lcdc_dev->reg_lock);
 460         if(likely(lcdc_dev->clk_on))
 461         {
 462                 switch(blank_mode)
 463                 {
 464                         case FB_BLANK_UNBLANK:
 465                                 LcdMskReg(lcdc_dev,DSP_CTRL,m_BLANK_MODE ,v_BLANK_MODE(0));
 466                                 break;
 467                         case FB_BLANK_NORMAL:
 468                                 LcdMskReg(lcdc_dev,DSP_CTRL,m_BLANK_MODE ,v_BLANK_MODE(1));
 469                                 break;
 470                         default:
 471                                 LcdMskReg(lcdc_dev,DSP_CTRL,m_BLANK_MODE ,v_BLANK_MODE(1));
 472                                 break;
 473                 }
 474                 LCDC_REG_CFG_DONE();
 475         }
 476         spin_unlock(&lcdc_dev->reg_lock);
 477
 478         return 0;
 479 }
 480
 481 static  int win0_display(struct rk2928_lcdc_device *lcdc_dev,struct layer_par *par )
 482 {
 483         u32 y_addr;
 484         u32 uv_addr;
 485         y_addr = par->smem_start + par->y_offset;
 486         uv_addr = par->cbr_start + par->c_offset;
 487         DBG(2,KERN_INFO "lcdc%d>>%s:y_addr:0x%x>>uv_addr:0x%x\n",lcdc_dev->id,__func__,y_addr,uv_addr);
 488
 489         spin_lock(&lcdc_dev->reg_lock);
 490         if(likely(lcdc_dev->clk_on))
 491         {
 492                 LcdWrReg(lcdc_dev, WIN0_YRGB_MST,y_addr);
 493                 LcdWrReg(lcdc_dev, WIN0_CBR_MST,uv_addr);
 494                 LCDC_REG_CFG_DONE();
 495         }
 496         spin_unlock(&lcdc_dev->reg_lock);
 497
 498         return 0;
 499
 500 }
 501
 502 static  int win1_display(struct rk2928_lcdc_device *lcdc_dev,struct layer_par *par )
 503 {
 504         u32 y_addr;
 505         u32 uv_addr;
 506         y_addr = par->smem_start + par->y_offset;
 507         uv_addr = par->cbr_start + par->c_offset;
 508         DBG(2,KERN_INFO "lcdc%d>>%s>>y_addr:0x%x>>uv_addr:0x%x\n",lcdc_dev->id,__func__,y_addr,uv_addr);
 509
 510         spin_lock(&lcdc_dev->reg_lock);
 511         if(likely(lcdc_dev->clk_on))
 512         {
 513                 LcdWrReg(lcdc_dev, WIN1_RGB_MST, y_addr);
 514                 LCDC_REG_CFG_DONE();
 515         }
 516         spin_unlock(&lcdc_dev->reg_lock);
 517
 518         return 0;
 519 }
 520
 521 static  int win0_set_par(struct rk2928_lcdc_device *lcdc_dev,rk_screen *screen,
 522         struct layer_par *par )
 523 {
 524         u32 xact, yact, xvir, yvir, xpos, ypos;
 525         u32 ScaleYrgbX = 0x1000;
 526         u32 ScaleYrgbY = 0x1000;
 527         u32 ScaleCbrX = 0x1000;
 528         u32 ScaleCbrY = 0x1000;
 529         u8 fmt_cfg = 0;
 530
 531         xact = par->xact;                           //active (origin) picture window width/height
 532         yact = par->yact;
 533         xvir = par->xvir;                          // virtual resolution
 534         yvir = par->yvir;
 535         xpos = par->xpos+screen->left_margin + screen->hsync_len;
 536         ypos = par->ypos+screen->upper_margin + screen->vsync_len;
 537
 538         ScaleYrgbX = CalScale(xact, par->xsize); //both RGB and yuv need this two factor
 539         ScaleYrgbY = CalScale(yact, par->ysize);
 540
 541         DBG(1,"%s for lcdc%d>>format:%d>>>xact:%d>>yact:%d>>xsize:%d>>ysize:%d>>xvir:%d>>yvir:%d>>xpos:%d>>ypos:%d>>\n",
 542                 __func__,lcdc_dev->id,par->format,xact,yact,par->xsize,par->ysize,xvir,yvir,xpos,ypos);
 543         switch (par->format)
 544         {
 545                 case XBGR888:
 546                 case ABGR888:
 547                 case ARGB888:
 548                         fmt_cfg = 0;
 549                         break;
 550                 case RGB888:
 551                         fmt_cfg = 1;
 552                         break;
 553                 case RGB565:
 554                         fmt_cfg = 2;
 555                         break;
 556                 case YUV422:// yuv422
 557                         fmt_cfg = 5;
 558                         ScaleCbrX = CalScale((xact/2), par->xsize);
 559                         ScaleCbrY = CalScale(yact, par->ysize);
 560                         break;
 561                 case YUV420: // yuv420
 562                         fmt_cfg = 4;
 563                         ScaleCbrX = CalScale(xact/2, par->xsize);
 564                         ScaleCbrY = CalScale(yact/2, par->ysize);
 565                         break;
 566                 case YUV444:// yuv444
 567                         fmt_cfg = 6;
 568                         ScaleCbrX = CalScale(xact, par->xsize);
 569                         ScaleCbrY = CalScale(yact, par->ysize);
 570                         break;
 571                 default:
 572                         printk("%s:un supported format\n",__func__);
 573                         break;
 574         }
 575
 576
 577         spin_lock(&lcdc_dev->reg_lock);
 578         if(likely(lcdc_dev->clk_on))
 579         {
 580                 LcdWrReg(lcdc_dev, WIN0_SCL_FACTOR_YRGB, v_X_SCL_FACTOR(ScaleYrgbX) | v_Y_SCL_FACTOR(ScaleYrgbY));
 581                 LcdWrReg(lcdc_dev, WIN0_SCL_FACTOR_CBR,v_X_SCL_FACTOR(ScaleCbrX)| v_Y_SCL_FACTOR(ScaleCbrY));
 582                 LcdMskReg(lcdc_dev, SYS_CFG, m_W0_FORMAT, v_W0_FORMAT(fmt_cfg));                //(inf->video_mode==0)
 583                 LcdWrReg(lcdc_dev, WIN0_ACT_INFO,v_ACT_WIDTH(xact) | v_ACT_HEIGHT(yact));
 584                 LcdWrReg(lcdc_dev, WIN0_DSP_ST, v_DSP_STX(xpos) | v_DSP_STY(ypos));
 585                 LcdWrReg(lcdc_dev, WIN0_DSP_INFO, v_DSP_WIDTH(par->xsize)| v_DSP_HEIGHT(par->ysize));
 586                 LcdMskReg(lcdc_dev,WIN0_COLOR_KEY_CTRL, m_COLORKEY_EN | m_KEYCOLOR,
 587                         v_COLORKEY_EN(1) | v_KEYCOLOR(0));
 588                 switch(par->format)
 589                 {
 590                         case XBGR888:
 591                                 LcdMskReg(lcdc_dev, WIN_VIR,m_WIN0_VIR,v_WIN0_ARGB888_VIRWIDTH(xvir));
 592                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W0_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(1));
 593                                 break;
 594                         case ARGB888:
 595                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN0_VIR,v_WIN0_ARGB888_VIRWIDTH(xvir));
 596                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W0_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(0));
 597                                 break;
 598                         case ABGR888:
 599                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN0_VIR,v_WIN0_ARGB888_VIRWIDTH(xvir));
 600                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W0_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(1));
 601                                 break;
 602                         case RGB888:  //rgb888
 603                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN0_VIR,v_WIN0_RGB888_VIRWIDTH(xvir));
 604                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W0_RGB_RB_SWAP,v_W0_RGB_RB_SWAP(0));
 605                                 break;
 606                         case RGB565:  //rgb565
 607                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN0_VIR,v_WIN0_RGB565_VIRWIDTH(xvir));
 608                                 LcdMskReg(lcdc_dev,DSP_CTRL,m_W0_RGB_RB_SWAP,v_W0_RGB_RB_SWAP(0));
 609                                 break;
 610                         case YUV422:
 611                         case YUV420:
 612                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN0_VIR,v_WIN0_YUV_VIRWIDTH(xvir));
 613                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W0_RGB_RB_SWAP,v_W0_RGB_RB_SWAP(0));
 614                                 break;
 615                         default:
 616                                 printk("%s:un supported format\n",__func__);
 617                                 break;
 618                 }
 619
 620                 LCDC_REG_CFG_DONE();
 621         }
 622         spin_unlock(&lcdc_dev->reg_lock);
 623
 624     return 0;
 625
 626 }
 627
 628 static int win1_set_par(struct rk2928_lcdc_device *lcdc_dev,rk_screen *screen,
 629         struct layer_par *par )
 630 {
 631         u32 xact, yact, xvir, yvir, xpos, ypos;
 632         u32 ScaleYrgbX = 0x1000;
 633         u32 ScaleYrgbY = 0x1000;
 634         u32 ScaleCbrX = 0x1000;
 635         u32 ScaleCbrY = 0x1000;
 636         u8 fmt_cfg = 0;
 637
 638         xact = par->xact;
 639         yact = par->yact;
 640         xvir = par->xvir;
 641         yvir = par->yvir;
 642         xpos = par->xpos+screen->left_margin + screen->hsync_len;
 643         ypos = par->ypos+screen->upper_margin + screen->vsync_len;
 644
 645         DBG(1,"%s for lcdc%d>>format:%d>>>xact:%d>>yact:%d>>xsize:%d>>ysize:%d>>xvir:%d>>yvir:%d>>xpos:%d>>ypos:%d>>\n",
 646                 __func__,lcdc_dev->id,par->format,xact,yact,par->xsize,par->ysize,xvir,yvir,xpos,ypos);
 647
 648
 649         spin_lock(&lcdc_dev->reg_lock);
 650         if(likely(lcdc_dev->clk_on))
 651         {
 652                 LcdWrReg(lcdc_dev, WIN1_DSP_ST,v_DSP_STX(xpos) | v_DSP_STY(ypos));
 653                 LcdWrReg(lcdc_dev, WIN1_DSP_INFO,v_DSP_WIDTH(par->xsize) | v_DSP_HEIGHT(par->ysize));
 654                 // enable win1 color key and set the color to black(rgb=0)
 655                 LcdMskReg(lcdc_dev, WIN1_COLOR_KEY_CTRL, m_COLORKEY_EN | m_KEYCOLOR,v_COLORKEY_EN(1) | v_KEYCOLOR(0));
 656
 657
 658                 switch(par->format)
 659                {
 660                         case XBGR888:
 661                                 fmt_cfg = 0;
 662                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN1_VIR,v_WIN1_ARGB888_VIRWIDTH(xvir));
 663                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W1_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(1));
 664                                 break;
 665                         case ABGR888:
 666                                 fmt_cfg = 0;
 667                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN1_VIR,v_WIN1_ARGB888_VIRWIDTH(xvir));
 668                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W1_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(1));
 669                                 break;
 670                         case ARGB888:
 671                                 fmt_cfg = 0;
 672                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN1_VIR,v_WIN1_ARGB888_VIRWIDTH(xvir));
 673                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W1_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(0));
 674                                 break;
 675                         case RGB888:  //rgb888
 676                                 fmt_cfg = 1;
 677                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN1_VIR,v_WIN1_RGB888_VIRWIDTH(xvir));
 678                                 LcdMskReg(lcdc_dev,DSP_CTRL,m_W1_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(0));
 679                                 break;
 680                         case RGB565:  //rgb565
 681                                 fmt_cfg = 2;
 682                                 LcdMskReg(lcdc_dev,WIN_VIR,m_WIN1_VIR,v_WIN1_RGB565_VIRWIDTH(xvir));
 683                                 LcdMskReg(lcdc_dev,SYS_CFG,m_W1_RGB_RB_SWAP,v_W1_RGB_RB_SWAP(0));
 684                                 break;
 685                         default:
 686                                 printk("%s:un supported format\n",__func__);
 687                                 break;
 688                }
 689
 690                 LcdMskReg(lcdc_dev,SYS_CFG, m_W1_FORMAT, v_W1_FORMAT(fmt_cfg));
 691                 //LCDC_REG_CFG_DONE();
 692         }
 693         spin_unlock(&lcdc_dev->reg_lock);
 694     return 0;
 695 }
 696
 697 static int rk2928_lcdc_open(struct rk_lcdc_device_driver *dev_drv,int layer_id,bool open)
 698 {
 699         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 700
 701         if(open)
 702         {
 703                 rk2928_load_screen(dev_drv,1);
 704         }
 705         if(layer_id == 0)
 706         {
 707                 win0_open(lcdc_dev,open);
 708         }
 709         else if(layer_id == 1)
 710         {
 711                 win1_open(lcdc_dev,open);
 712         }
 713
 714         return 0;
 715 }
 716
 717 static int rk2928_lcdc_set_par(struct rk_lcdc_device_driver *dev_drv,int layer_id)
 718 {
 719         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 720         struct layer_par *par = NULL;
 721         rk_screen *screen = dev_drv->cur_screen;
 722         rk_screen *screen0 = dev_drv->screen0;
 723         u32 Scl_X = 0x1000;
 724         u32 Scl_Y = 0x1000;
 725
 726         if(!screen)
 727         {
 728                 printk(KERN_ERR "screen is null!\n");
 729                 return -ENOENT;
 730         }
 731         if(layer_id==0)
 732         {
 733                 par = dev_drv->layer_par[0];
 734                 win0_set_par(lcdc_dev,screen,par);
 735         }
 736         else if(layer_id==1)
 737         {
 738                 par = dev_drv->layer_par[1];
 739                 win1_set_par(lcdc_dev,screen,par);
 740         }
 741         Scl_X = CalScale(screen->x_res - 1,screen0->x_res - 1);
 742         if((screen->y_res-1)/(screen0->x_res -1) < 2)
 743         {
 744
 745                 Scl_Y = CalScale(screen->y_res - 1 ,screen0->y_res - 1);
 746         }
 747         else
 748         {
 749                 Scl_Y = CalScale(screen->y_res - 2 ,screen0->y_res - 1);
 750         }
 751         LcdWrReg(lcdc_dev,SCL_REG1,v_SCL_V_FACTOR(Scl_Y)|v_SCL_H_FACTOR(Scl_X));
 752
 753         return 0;
 754 }
 755
 756 int rk2928_lcdc_pan_display(struct rk_lcdc_device_driver * dev_drv,int layer_id)
 757 {
 758         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 759         struct layer_par *par = NULL;
 760         rk_screen *screen = dev_drv->cur_screen;
 761         unsigned long flags;
 762         int timeout;
 763         if(!screen)
 764         {
 765                 printk(KERN_ERR "screen is null!\n");
 766                 return -ENOENT;
 767         }
 768         if(layer_id==0)
 769         {
 770                 par = dev_drv->layer_par[0];
 771                 win0_display(lcdc_dev,par);
 772         }
 773         else if(layer_id==1)
 774         {
 775                 par = dev_drv->layer_par[1];
 776                 win1_display(lcdc_dev,par);
 777         }
 778         if((dev_drv->first_frame))  //this is the first frame of the system ,enable frame start interrupt
 779         {
 780                 dev_drv->first_frame = 0;
 781                 LcdMskReg(lcdc_dev,INT_STATUS,m_FRM_START_INT_CLEAR |m_FRM_START_INT_EN ,
 782                           v_FRM_START_INT_CLEAR(1) | v_FRM_START_INT_EN(1));
 783                 LCDC_REG_CFG_DONE();  // write any value to  REG_CFG_DONE let config become effective
 784
 785         }
 786
 787         if(dev_drv->num_buf < 3) //3buffer ,no need to  wait for sysn
 788         {
 789                 spin_lock_irqsave(&dev_drv->cpl_lock,flags);
 790                 init_completion(&dev_drv->frame_done);
 791                 spin_unlock_irqrestore(&dev_drv->cpl_lock,flags);
 792                 timeout = wait_for_completion_timeout(&dev_drv->frame_done,msecs_to_jiffies(dev_drv->cur_screen->ft+5));
 793                 if(!timeout&&(!dev_drv->frame_done.done))
 794                 {
 795                         //printk(KERN_ERR "wait for new frame start time out!\n");
 796                         return -ETIMEDOUT;
 797                 }
 798         }
 799
 800         return 0;
 801 }
 802
 803 int rk2928_lcdc_ioctl(struct rk_lcdc_device_driver * dev_drv,unsigned int cmd, unsigned long arg,int layer_id)
 804 {
 805         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 806         u32 panel_size[2];
 807         void __user *argp = (void __user *)arg;
 808         int ret = 0;
 809         switch(cmd)
 810         {
 811                 case RK_FBIOGET_PANEL_SIZE:    //get panel size
 812                         panel_size[0] = dev_drv->screen0->x_res;
 813                         panel_size[1] = dev_drv->screen0->y_res;
 814                         if(copy_to_user(argp, panel_size, 8))
 815                                 return -EFAULT;
 816                         break;
 817                 default:
 818                         break;
 819         }
 820
 821         return ret;
 822 }
 823 static int rk2928_lcdc_get_layer_state(struct rk_lcdc_device_driver *dev_drv,int layer_id)
 824 {
 825         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 826         struct layer_par *par = dev_drv->layer_par[layer_id];
 827
 828         spin_lock(&lcdc_dev->reg_lock);
 829         if(lcdc_dev->clk_on)
 830         {
 831                 if(layer_id == 0)
 832                 {
 833                         par->state = LcdReadBit(lcdc_dev,SYS_CFG,m_W0_EN);
 834                 }
 835                 else if( layer_id == 1)
 836                 {
 837                         par->state = LcdReadBit(lcdc_dev,SYS_CFG,m_W1_EN);
 838                 }
 839         }
 840         spin_unlock(&lcdc_dev->reg_lock);
 841
 842         return par->state;
 843
 844 }
 845
 846 /***********************************
 847 overlay manager
 848 swap:1 win0 on the top of win1
 849         0 win1 on the top of win0
 850 set  : 1 set overlay
 851         0 get overlay state
 852 ************************************/
 853 static int rk2928_lcdc_ovl_mgr(struct rk_lcdc_device_driver *dev_drv,int swap,bool set)
 854 {
 855         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 856         int ovl;
 857         spin_lock(&lcdc_dev->reg_lock);
 858         if(lcdc_dev->clk_on)
 859         {
 860                 if(set)  //set overlay
 861                 {
 862                         LcdMskReg(lcdc_dev,DSP_CTRL,m_W0W1_POSITION_SWAP,v_W0W1_POSITION_SWAP(swap));
 863                         LCDC_REG_CFG_DONE();
 864                         ovl = swap;
 865                 }
 866                 else  //get overlay
 867                 {
 868                         ovl = LcdReadBit(lcdc_dev,DSP_CTRL,m_W0W1_POSITION_SWAP);
 869                 }
 870         }
 871         else
 872         {
 873                 ovl = -EPERM;
 874         }
 875         spin_unlock(&lcdc_dev->reg_lock);
 876
 877         return ovl;
 878 }
 879
 880 static ssize_t dump_win0_disp_info(struct rk2928_lcdc_device *lcdc_dev,char *buf)
 881 {
 882         char format[9] = "NULL";
 883         u32 fmt_id = LcdRdReg(lcdc_dev,SYS_CFG);
 884         u32 xvir,act_info,dsp_info,dsp_st,factor;
 885         u16 x_act,y_act,x_dsp,y_dsp,x_factor,y_factor;
 886         u16 x_scale,y_scale;
 887         switch((fmt_id&m_W0_FORMAT)>>3)
 888         {
 889                 case 0:
 890                         strcpy(format,"ARGB888");
 891                         break;
 892                 case 1:
 893                         strcpy(format,"RGB888");
 894                         break;
 895                 case 2:
 896                         strcpy(format,"RGB565");
 897                         break;
 898                 case 4:
 899                         strcpy(format,"YCbCr422");
 900                         break;
 901                 case 5:
 902                         strcpy(format,"YCbCr420");
 903                         break;
 904                 case 6:
 905                         strcpy(format,"YCbCr444");
 906                         break;
 907                 default:
 908                         strcpy(format,"inval\n");
 909                         break;
 910         }
 911
 912         xvir = LcdRdReg(lcdc_dev,WIN_VIR)&0xffff;
 913         act_info = LcdRdReg(lcdc_dev,WIN0_ACT_INFO);
 914         dsp_info = LcdRdReg(lcdc_dev,WIN0_DSP_INFO);
 915         dsp_st = LcdRdReg(lcdc_dev,WIN0_DSP_ST);
 916         factor = LcdRdReg(lcdc_dev,WIN0_SCL_FACTOR_YRGB);
 917         x_act =  (act_info&0xffff) + 1;
 918         y_act = (act_info>>16) + 1;
 919         x_dsp = (dsp_info&0xffff) + 1;
 920         y_dsp = (dsp_info>>16) + 1;
 921         x_factor = factor&0xffff;
 922         y_factor = factor>>16;
 923         x_scale = 4096*100/x_factor;
 924         y_scale = 4096*100/y_factor;
 925         return snprintf(buf,PAGE_SIZE,"xvir:%d\nxact:%d\nyact:%d\nxdsp:%d\nydsp:%d\nx_st:%d\ny_st:%d\nx_scale:%d.%d\ny_scale:%d.%d\nformat:%s\n",
 926                 xvir,x_act,y_act,x_dsp,y_dsp,dsp_st&0xffff,dsp_st>>16,x_scale/100,x_scale%100,y_scale/100,y_scale%100,format);
 927
 928 }
 929
 930 static ssize_t dump_win1_disp_info(struct rk2928_lcdc_device *lcdc_dev,char *buf)
 931 {
 932         char format[9] = "NULL";
 933         u32 fmt_id = LcdRdReg(lcdc_dev,SYS_CFG);
 934         u32 xvir,act_info,dsp_info,dsp_st,factor;
 935         u16 x_act,y_act,x_dsp,y_dsp,x_factor,y_factor;
 936         u16 x_scale,y_scale;
 937         switch((fmt_id&m_W1_FORMAT)>>6)
 938         {
 939                 case 0:
 940                         strcpy(format,"ARGB888");
 941                         break;
 942                 case 1:
 943                         strcpy(format,"RGB888");
 944                         break;
 945                 case 2:
 946                         strcpy(format,"RGB565");
 947                         break;
 948                 default:
 949                         strcpy(format,"inval\n");
 950                         break;
 951         }
 952
 953         xvir = (LcdRdReg(lcdc_dev,WIN_VIR)>>16)&0xfff;
 954         dsp_info = LcdRdReg(lcdc_dev,WIN1_DSP_INFO);
 955         dsp_st = LcdRdReg(lcdc_dev,WIN1_DSP_ST);
 956
 957         x_dsp = dsp_info&0xffff;
 958         y_dsp = dsp_info>>16;
 959
 960         return snprintf(buf,PAGE_SIZE,"xvir:%d\nxdsp:%d\nydsp:%d\nx_st:%d\ny_st:%d\nformat:%s\n",
 961                 xvir,x_dsp,y_dsp,dsp_st&0xffff,dsp_st>>16,format);
 962 }
 963
 964 static ssize_t  rk2928_lcdc_get_disp_info(struct rk_lcdc_device_driver *dev_drv,char *buf,int layer_id)
 965 {
 966         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 967         if(layer_id == 0)
 968         {
 969                 return dump_win0_disp_info(lcdc_dev,buf);
 970         }
 971         else if(layer_id == 1)
 972         {
 973                 return dump_win1_disp_info(lcdc_dev,buf);
 974         }
 975
 976         return 0;
 977 }
 978
 979
 980
 981 /*******************************************
 982 lcdc fps manager,set or get lcdc fps
 983 set:0 get
 984      1 set
 985 ********************************************/
 986 static int rk2928_lcdc_fps_mgr(struct rk_lcdc_device_driver *dev_drv,int fps,bool set)
 987 {
 988         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
 989         rk_screen * screen = dev_drv->cur_screen;
 990         u64 ft = 0;
 991         u32 dotclk;
 992         int ret;
 993
 994         if(set)
 995         {
 996                 ft = div_u64(1000000000000llu,fps);
 997                 dev_drv->pixclock = div_u64(ft,(screen->upper_margin + screen->lower_margin + screen->y_res +screen->vsync_len)*
 998                                 (screen->left_margin + screen->right_margin + screen->x_res + screen->hsync_len));
 999                 dotclk = div_u64(1000000000000llu,dev_drv->pixclock);
1000                 ret = clk_set_rate(lcdc_dev->dclk, dotclk);
1001                 if(ret)
1002                 {
1003                         printk(KERN_ERR ">>>>>> set lcdc%d dclk failed\n",lcdc_dev->id);
1004                 }
1005                 dev_drv->pixclock = lcdc_dev->pixclock = div_u64(1000000000000llu, clk_get_rate(lcdc_dev->dclk));
1006
1007         }
1008
1009         ft = (u64)(screen->upper_margin + screen->lower_margin + screen->y_res +screen->vsync_len)*
1010         (screen->left_margin + screen->right_margin + screen->x_res + screen->hsync_len)*
1011         (dev_drv->pixclock);       // one frame time ,(pico seconds)
1012         fps = div64_u64(1000000000000llu,ft);
1013         screen->ft = 1000/fps ;  //one frame time in ms
1014         return fps;
1015 }
1016
1017
1018 static int rk2928_fb_layer_remap(struct rk_lcdc_device_driver *dev_drv,
1019         enum fb_win_map_order order)
1020 {
1021         mutex_lock(&dev_drv->fb_win_id_mutex);
1022         if(order == FB_DEFAULT_ORDER)
1023         {
1024                 order = FB0_WIN0_FB1_WIN1_FB2_WIN2;
1025         }
1026         dev_drv->fb2_win_id  = order/100;
1027         dev_drv->fb1_win_id = (order/10)%10;
1028         dev_drv->fb0_win_id = order%10;
1029         mutex_unlock(&dev_drv->fb_win_id_mutex);
1030
1031         printk("fb0:win%d\nfb1:win%d\nfb2:win%d\n",dev_drv->fb0_win_id,dev_drv->fb1_win_id,
1032                 dev_drv->fb2_win_id);
1033
1034         return 0;
1035 }
1036
1037 static int rk2928_fb_get_layer(struct rk_lcdc_device_driver *dev_drv,const char *id)
1038 {
1039         int layer_id = 0;
1040         mutex_lock(&dev_drv->fb_win_id_mutex);
1041         if(!strcmp(id,"fb0"))
1042         {
1043                 layer_id = dev_drv->fb0_win_id;
1044         }
1045         else if(!strcmp(id,"fb1"))
1046         {
1047                 layer_id = dev_drv->fb1_win_id;
1048         }
1049         else if(!strcmp(id,"fb2"))
1050         {
1051                 layer_id = dev_drv->fb2_win_id;
1052         }
1053         else
1054         {
1055                 printk(KERN_ERR "%s>>un supported %s\n",__func__,id);
1056                 layer_id = -1;
1057         }
1058         mutex_unlock(&dev_drv->fb_win_id_mutex);
1059         //printk("%s %s win%d\n",__func__,id,layer_id);
1060         return  layer_id;
1061 }
1062
1063 static int rk2928_lcdc_hdmi_process(struct rk_lcdc_device_driver *dev_drv,int mode)
1064 {
1065 #if !defined(CONFIG_ONE_LCDC_DUAL_OUTPUT_INF)
1066         printk("%s>>>>>>>>mode:%d\n",__func__,mode);
1067         if(mode)
1068         {
1069                 rk2928_lcdc_iomux(dev_drv->screen0,0); //switch to gpio mode,to avoid  current leakage
1070                 if(dev_drv->screen_ctr_info->io_disable)
1071                         dev_drv->screen_ctr_info->io_disable();
1072         }
1073         else
1074         {
1075                 rk2928_lcdc_iomux(dev_drv->screen0,1); //switch to gpio mode,to avoid  current leakage
1076                 if(dev_drv->screen_ctr_info->io_enable)
1077                         dev_drv->screen_ctr_info->io_enable();
1078         }
1079 #endif
1080
1081         return 0;
1082
1083 }
1084 int rk2928_lcdc_early_suspend(struct rk_lcdc_device_driver *dev_drv)
1085 {
1086         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
1087
1088         if(dev_drv->screen0->standby)
1089                 dev_drv->screen0->standby(1);
1090         if(dev_drv->screen_ctr_info->io_disable)
1091                 dev_drv->screen_ctr_info->io_disable();
1092
1093         if(dev_drv->cur_screen->sscreen_set)
1094                 dev_drv->cur_screen->sscreen_set(dev_drv->cur_screen , 0);
1095
1096         spin_lock(&lcdc_dev->reg_lock);
1097         if(likely(lcdc_dev->clk_on))
1098         {
1099                 lcdc_dev->clk_on = 0;
1100                 LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_START_INT_CLEAR, v_FRM_START_INT_CLEAR(1));
1101                 LcdSetBit(lcdc_dev,DSP_CTRL,m_BLACK_MODE);
1102                 LcdMskReg(lcdc_dev, SYS_CFG,m_DSP_OUT_ZERO | m_LCDC_STANDBY,
1103                         v_DSP_OUT_ZERO(1) | v_LCDC_STANDBY(1));
1104                 LCDC_REG_CFG_DONE();
1105                 spin_unlock(&lcdc_dev->reg_lock);
1106         }
1107         else  //clk already disabled
1108         {
1109                 spin_unlock(&lcdc_dev->reg_lock);
1110                 return 0;
1111         }
1112
1113
1114         mdelay(10);
1115         rk2928_lcdc_iomux(dev_drv->screen0,0); //switch to gpio mode,to avoid  current leakage
1116         clk_disable(lcdc_dev->dclk);
1117         clk_disable(lcdc_dev->hclk);
1118         clk_disable(lcdc_dev->aclk);
1119         clk_disable(lcdc_dev->pd);
1120
1121         return 0;
1122 }
1123
1124
1125
1126 int rk2928_lcdc_early_resume(struct rk_lcdc_device_driver *dev_drv)
1127 {
1128         struct rk2928_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk2928_lcdc_device,driver);
1129
1130         if(dev_drv->screen_ctr_info->io_enable)                 //power on
1131                 dev_drv->screen_ctr_info->io_enable();
1132
1133         if(!lcdc_dev->clk_on)
1134         {
1135                 clk_enable(lcdc_dev->pd);
1136                 clk_enable(lcdc_dev->hclk);
1137                 clk_enable(lcdc_dev->dclk);
1138                 clk_enable(lcdc_dev->aclk);
1139         }
1140         rk2928_lcdc_iomux(dev_drv->screen0,1); //switch to lcdc io
1141         memcpy((u8*)lcdc_dev->preg, (u8*)&lcdc_dev->regbak, 0xc4);  //resume reg
1142
1143         spin_lock(&lcdc_dev->reg_lock);
1144         if(lcdc_dev->atv_layer_cnt)
1145         {
1146                 LcdMskReg(lcdc_dev, SYS_CFG,m_DSP_OUT_ZERO | m_LCDC_STANDBY,
1147                         v_DSP_OUT_ZERO(0) | v_LCDC_STANDBY(0));
1148                 LcdClrBit(lcdc_dev,DSP_CTRL,m_BLACK_MODE);
1149                 LCDC_REG_CFG_DONE();
1150         }
1151         lcdc_dev->clk_on = 1;
1152         spin_unlock(&lcdc_dev->reg_lock);
1153
1154
1155         if(dev_drv->cur_screen->sscreen_set)
1156                 dev_drv->cur_screen->sscreen_set(dev_drv->cur_screen , 1);
1157
1158         if(dev_drv->screen0->standby)
1159                 dev_drv->screen0->standby(0);         //screen wake up
1160
1161
1162         return 0;
1163 }
1164 static irqreturn_t rk2928_lcdc_isr(int irq, void *dev_id)
1165 {
1166         struct rk2928_lcdc_device *lcdc_dev = (struct rk2928_lcdc_device *)dev_id;
1167
1168         ktime_t timestamp = ktime_get();
1169
1170         LcdMskReg(lcdc_dev, INT_STATUS, m_FRM_START_INT_CLEAR, v_FRM_START_INT_CLEAR(1));
1171         //LCDC_REG_CFG_DONE();
1172         //LcdMskReg(lcdc_dev, INT_STATUS, m_LINE_FLAG_INT_CLEAR, v_LINE_FLAG_INT_CLEAR(1));
1173
1174         if(lcdc_dev->driver.num_buf < 3)  //three buffer ,no need to wait for sync
1175         {
1176                 spin_lock(&(lcdc_dev->driver.cpl_lock));
1177                 complete(&(lcdc_dev->driver.frame_done));
1178                 spin_unlock(&(lcdc_dev->driver.cpl_lock));
1179         }
1180
1181         lcdc_dev->driver.vsync_info.timestamp = timestamp;
1182         wake_up_interruptible_all(&lcdc_dev->driver.vsync_info.wait);
1183         return IRQ_HANDLED;
1184 }
1185
1186 static struct layer_par lcdc_layer[] = {
1187         [0] = {
1188                 .name           = "win0",
1189                 .id             = 0,
1190                 .support_3d     = true,
1191         },
1192         [1] = {
1193                 .name           = "win1",
1194                 .id             = 1,
1195                 .support_3d     = false,
1196         },
1197 };
1198
1199 static struct rk_lcdc_device_driver lcdc_driver = {
1200         .name                   = "lcdc",
1201         .def_layer_par          = lcdc_layer,
1202         .num_layer              = ARRAY_SIZE(lcdc_layer),
1203         .open                   = rk2928_lcdc_open,
1204         .init_lcdc              = init_rk2928_lcdc,
1205         .ioctl                  = rk2928_lcdc_ioctl,
1206         .suspend                = rk2928_lcdc_early_suspend,
1207         .resume                 = rk2928_lcdc_early_resume,
1208         .set_par                = rk2928_lcdc_set_par,
1209         .blank                  = rk2928_lcdc_blank,
1210         .pan_display            = rk2928_lcdc_pan_display,
1211         .load_screen            = rk2928_load_screen,
1212         .get_layer_state        = rk2928_lcdc_get_layer_state,
1213         .ovl_mgr                = rk2928_lcdc_ovl_mgr,
1214         .get_disp_info          = rk2928_lcdc_get_disp_info,
1215         .fps_mgr                = rk2928_lcdc_fps_mgr,
1216         .fb_get_layer           = rk2928_fb_get_layer,
1217         .fb_layer_remap         = rk2928_fb_layer_remap,
1218         .lcdc_hdmi_process      = rk2928_lcdc_hdmi_process,
1219 };
1220 #ifdef CONFIG_PM
1221 static int rk2928_lcdc_suspend(struct platform_device *pdev, pm_message_t state)
1222 {
1223         return 0;
1224 }
1225
1226 static int rk2928_lcdc_resume(struct platform_device *pdev)
1227 {
1228         return 0;
1229 }
1230
1231 #else
1232 #define rk2928_lcdc_suspend NULL
1233 #define rk2928_lcdc_resume NULL
1234 #endif
1235
1236 static int __devinit rk2928_lcdc_probe (struct platform_device *pdev)
1237 {
1238         struct rk2928_lcdc_device *lcdc_dev=NULL;
1239         rk_screen *screen0;
1240         rk_screen *screen1;
1241         struct rk29fb_info *screen_ctr_info;
1242         struct resource *res = NULL;
1243         struct resource *mem;
1244         int ret = 0;
1245
1246         /*************Malloc rk2928lcdc_inf and set it to pdev for drvdata**********/
1247         lcdc_dev = kzalloc(sizeof(struct rk2928_lcdc_device), GFP_KERNEL);
1248         if(!lcdc_dev)
1249         {
1250                 dev_err(&pdev->dev, ">>rk2928 lcdc device kmalloc fail!");
1251                 return -ENOMEM;
1252         }
1253         platform_set_drvdata(pdev, lcdc_dev);
1254         lcdc_dev->id = pdev->id;
1255         screen_ctr_info = (struct rk29fb_info * )pdev->dev.platform_data;
1256         screen0 =  kzalloc(sizeof(rk_screen), GFP_KERNEL); //rk2928 has one lcdc but two outputs
1257         if(!screen0)
1258         {
1259                 dev_err(&pdev->dev, ">>rk2928 lcdc screen1 kmalloc fail!");
1260                 ret =  -ENOMEM;
1261                 goto err0;
1262         }
1263         screen0->lcdc_id = 0;  //this id can be changed dynamic
1264         screen0->screen_id = 0; //this id is fixed
1265         screen1 =  kzalloc(sizeof(rk_screen), GFP_KERNEL);
1266         if(!screen1)
1267         {
1268                 dev_err(&pdev->dev, ">>rk2928 lcdc screen1 kmalloc fail!");
1269                 ret =  -ENOMEM;
1270                 goto err0;
1271         }
1272         screen1->lcdc_id = 1;
1273         screen1->screen_id = 1;
1274
1275         /****************get lcdc0 reg  *************************/
1276         res = platform_get_resource(pdev, IORESOURCE_MEM,0);
1277         if (res == NULL)
1278         {
1279                 dev_err(&pdev->dev, "failed to get io resource for lcdc%d \n",lcdc_dev->id);
1280                 ret = -ENOENT;
1281                 goto err1;
1282         }
1283         lcdc_dev->reg_phy_base = res->start;
1284         lcdc_dev->len = resource_size(res);
1285         mem = request_mem_region(lcdc_dev->reg_phy_base, resource_size(res), pdev->name);
1286         if (mem == NULL)
1287         {
1288                 dev_err(&pdev->dev, "failed to request mem region for lcdc%d\n",lcdc_dev->id);
1289                 ret = -ENOENT;
1290                 goto err1;
1291         }
1292         lcdc_dev->reg_vir_base = ioremap(lcdc_dev->reg_phy_base,  resource_size(res));
1293         if (lcdc_dev->reg_vir_base == NULL)
1294         {
1295                 dev_err(&pdev->dev, "cannot map IO\n");
1296                 ret = -ENXIO;
1297                 goto err2;
1298         }
1299
1300         lcdc_dev->preg = (LCDC_REG*)lcdc_dev->reg_vir_base;
1301         printk("lcdc%d:reg_phy_base = 0x%08x,reg_vir_base:0x%p\n",pdev->id,lcdc_dev->reg_phy_base, lcdc_dev->preg);
1302         lcdc_dev->driver.dev=&pdev->dev;
1303         lcdc_dev->driver.screen0 = screen0;  //direct out put
1304         lcdc_dev->driver.screen1 = screen1; //out put from scale
1305         lcdc_dev->driver.cur_screen = screen0;
1306         lcdc_dev->driver.screen_ctr_info = screen_ctr_info;
1307         spin_lock_init(&lcdc_dev->reg_lock);
1308         lcdc_dev->irq = platform_get_irq(pdev, 0);
1309         if(lcdc_dev->irq < 0)
1310         {
1311                 dev_err(&pdev->dev, "cannot find IRQ\n");
1312                 goto err3;
1313         }
1314         ret = request_irq(lcdc_dev->irq, rk2928_lcdc_isr, IRQF_DISABLED,dev_name(&pdev->dev),lcdc_dev);
1315         if (ret)
1316         {
1317                dev_err(&pdev->dev, "cannot requeset irq %d - err %d\n", lcdc_dev->irq, ret);
1318                ret = -EBUSY;
1319                goto err3;
1320         }
1321
1322         if(screen_ctr_info->set_screen_info)
1323         {
1324                 screen_ctr_info->set_screen_info(screen0,screen_ctr_info->lcd_info);
1325                 if(SCREEN_NULL==screen0->type)
1326                 {
1327                         printk(KERN_WARNING "no display device on lcdc%d!?\n",lcdc_dev->id);
1328                         ret = -ENODEV;
1329                 }
1330                 if(screen_ctr_info->io_init)
1331                         screen_ctr_info->io_init(NULL);
1332         }
1333         else
1334         {
1335                 printk(KERN_WARNING "no display device on lcdc%d!?\n",lcdc_dev->id);
1336                 ret =  -ENODEV;
1337                 goto err4;
1338         }
1339
1340         ret = rk_fb_register(&(lcdc_dev->driver),&lcdc_driver,lcdc_dev->id);
1341         if(ret < 0)
1342         {
1343                 printk(KERN_ERR "register fb for lcdc%d failed!\n",lcdc_dev->id);
1344                 goto err4;
1345         }
1346         printk("rk2928 lcdc%d probe ok!\n",lcdc_dev->id);
1347
1348         return 0;
1349
1350 err4:
1351         free_irq(lcdc_dev->irq,lcdc_dev);
1352 err3:
1353         iounmap(lcdc_dev->reg_vir_base);
1354 err2:
1355         release_mem_region(lcdc_dev->reg_phy_base,resource_size(res));
1356 err1:
1357         kfree(screen0);
1358 err0:
1359         platform_set_drvdata(pdev, NULL);
1360         kfree(lcdc_dev);
1361         return ret;
1362
1363 }
1364 static int __devexit rk2928_lcdc_remove(struct platform_device *pdev)
1365 {
1366         struct rk2928_lcdc_device *lcdc_dev = platform_get_drvdata(pdev);
1367         rk_fb_unregister(&(lcdc_dev->driver));
1368         rk2928_lcdc_deinit(lcdc_dev);
1369         iounmap(lcdc_dev->reg_vir_base);
1370         release_mem_region(lcdc_dev->reg_phy_base,lcdc_dev->len);
1371         kfree(lcdc_dev->screen);
1372         kfree(lcdc_dev);
1373         return 0;
1374 }
1375
1376 static void rk2928_lcdc_shutdown(struct platform_device *pdev)
1377 {
1378         struct rk2928_lcdc_device *lcdc_dev = platform_get_drvdata(pdev);
1379         if(lcdc_dev->driver.cur_screen->standby) //standby the screen if necessary
1380                 lcdc_dev->driver.cur_screen->standby(1);
1381         if(lcdc_dev->driver.screen_ctr_info->io_disable) //power off the screen if necessary
1382                 lcdc_dev->driver.screen_ctr_info->io_disable();
1383         if(lcdc_dev->driver.cur_screen->sscreen_set) //turn off  lvds
1384                 lcdc_dev->driver.cur_screen->sscreen_set(lcdc_dev->driver.cur_screen , 0);
1385         //rk_fb_unregister(&(lcdc_dev->driver));
1386         rk2928_lcdc_deinit(lcdc_dev);
1387         /*iounmap(lcdc_dev->reg_vir_base);
1388         release_mem_region(lcdc_dev->reg_phy_base,lcdc_dev->len);
1389         kfree(lcdc_dev->screen);
1390         kfree(lcdc_dev);*/
1391 }
1392
1393
1394 static struct platform_driver rk2928lcdc_driver = {
1395         .probe          = rk2928_lcdc_probe,
1396         .remove         = __devexit_p(rk2928_lcdc_remove),
1397         .driver         = {
1398                 .name   = "rk2928-lcdc",
1399                 .owner  = THIS_MODULE,
1400         },
1401         .suspend        = rk2928_lcdc_suspend,
1402         .resume         = rk2928_lcdc_resume,
1403         .shutdown   = rk2928_lcdc_shutdown,
1404 };
1405
1406 static int __init rk2928_lcdc_init(void)
1407 {
1408     return platform_driver_register(&rk2928lcdc_driver);
1409 }
1410
1411 static void __exit rk2928_lcdc_exit(void)
1412 {
1413         platform_driver_unregister(&rk2928lcdc_driver);
1414 }
1415
1416
1417
1418 fs_initcall(rk2928_lcdc_init);
1419 module_exit(rk2928_lcdc_exit);
1420
1421
1422