drivers/video/rk29_fb.c

   1 /*
   2  * drivers/video/rk29_fb.c
   3  *
   4  * Copyright (C) 2010 ROCKCHIP, Inc.
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/kernel.h>
  18 #include <linux/errno.h>
  19 #include <linux/string.h>
  20 #include <linux/mm.h>
  21 #include <linux/slab.h>
  22 #include <linux/delay.h>
  23 #include <linux/device.h>
  24 #include <linux/fb.h>
  25 #include <linux/init.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/clk.h>
  30 #include <linux/backlight.h>
  31 #include <linux/timer.h>
  32 #include <linux/time.h>
  33 #include <linux/wait.h>
  34 #include <linux/earlysuspend.h>
  35 #include <linux/cpufreq.h>
  36
  37
  38 #include <asm/io.h>
  39 #include <asm/div64.h>
  40 #include <asm/uaccess.h>
  41
  42 #include "rk29_fb.h"
  43
  44 #ifdef CONFIG_PM
  45 #include <linux/pm.h>
  46 #endif
  47
  48 #include <mach/iomux.h>
  49 #include <mach/gpio.h>
  50 #include <mach/board.h>
  51 #include <mach/rk29_iomap.h>
  52 //#include <asm/uaccess.h>
  53
  54 #include "./display/screen/screen.h"
  55
  56 #define ANDROID_USE_THREE_BUFS  1       //android use three buffers to accelerate UI display in rgb plane
  57
  58 #if 0
  59         #define fbprintk(msg...)        printk(msg);
  60 #else
  61         #define fbprintk(msg...)
  62 #endif
  63
  64
  65 #if 0
  66         #define fbprintk2(msg...)       printk(msg);
  67 #else
  68         #define fbprintk2(msg...)
  69 #endif
  70
  71 #define LcdReadBit(inf, addr, msk)      ((inf->regbak.addr=inf->preg->addr)&(msk))
  72 #define LcdWrReg(inf, addr, val)        inf->preg->addr=inf->regbak.addr=(val)
  73 #define LcdRdReg(inf, addr)             (inf->preg->addr)
  74 #define LcdSetBit(inf, addr, msk)       inf->preg->addr=((inf->regbak.addr) |= (msk))
  75 #define LcdClrBit(inf, addr, msk)       inf->preg->addr=((inf->regbak.addr) &= ~(msk))
  76 #define LcdSetRegBit(inf, addr, msk)    inf->preg->addr=((inf->preg->addr) |= (msk))
  77 #define LcdMskReg(inf, addr, msk, val)  (inf->regbak.addr)&=~(msk);   inf->preg->addr=(inf->regbak.addr|=(val))
  78
  79
  80 #define IsMcuLandscape()                ((SCREEN_MCU==inf->cur_screen->type) && (0==inf->mcu_scandir))
  81 #define IsMcuUseFmk()                   ( (2==inf->cur_screen->mcu_usefmk) || (1==inf->cur_screen->mcu_usefmk))
  82
  83 #define CalScaleW0(x, y)                     (((u32)x*0x1000)/y)
  84
  85 struct rk29fb_rgb {
  86         struct fb_bitfield      red;
  87         struct fb_bitfield      green;
  88         struct fb_bitfield      blue;
  89         struct fb_bitfield      transp;
  90 };
  91
  92 static struct rk29fb_rgb def_rgb_16 = {
  93      red:    { offset: 11, length: 5, },
  94      green:  { offset: 5,  length: 6, },
  95      blue:   { offset: 0,  length: 5, },
  96      transp: { offset: 0,  length: 0, },
  97 };
  98
  99 struct win0_par {
 100         u32 refcount;
 101         u32     pseudo_pal[16];
 102         u32 y_offset;
 103         u32 uv_offset;
 104
 105     u8 par_seted;
 106     u8 addr_seted;
 107 };
 108
 109 struct win1_par {
 110         u32 refcount;
 111         u32     pseudo_pal[16];
 112         int lstblank;
 113 };
 114
 115 struct rk29fb_inf {
 116     struct fb_info *win0fb;
 117     struct fb_info *win1fb;
 118
 119     void __iomem *reg_vir_base;  // virtual basic address of lcdc register
 120         u32 reg_phy_base;       // physical basic address of lcdc register
 121         u32 len;               // physical map length of lcdc register
 122
 123     struct clk      *clk;
 124     struct clk      *dclk;            //lcdc dclk
 125     struct clk      *dclk_parent;     //lcdc dclk divider frequency source
 126     struct clk      *dclk_divider;    //lcdc demodulator divider frequency
 127     struct clk      *aclk;   //lcdc share memory frequency
 128     struct clk      *aclk_parent;     //lcdc aclk divider frequency source
 129     unsigned long       dclk_rate;
 130
 131     /* lcdc reg base address and backup reg */
 132     LCDC_REG *preg;
 133     LCDC_REG regbak;
 134
 135         int in_suspend;
 136
 137     /* variable used in mcu panel */
 138         int mcu_needflush;
 139         int mcu_isrcnt;
 140         u16 mcu_scandir;
 141         struct timer_list mcutimer;
 142         int mcu_status;
 143         u8 mcu_fmksync;
 144         int mcu_usetimer;
 145         int mcu_stopflush;
 146
 147     /* external memery */
 148         char __iomem *screen_base2;
 149     __u32 smem_len2;
 150     unsigned long  smem_start2;
 151
 152     char __iomem *cursor_base;   /* cursor Virtual address*/
 153     __u32 cursor_size;           /* Amount of ioremapped VRAM or 0 */
 154     unsigned long  cursor_start;
 155
 156     struct rk29fb_screen lcd_info;
 157     struct rk29fb_screen tv_info[5];
 158     struct rk29fb_screen hdmi_info[2];
 159     struct rk29fb_screen *cur_screen;
 160 #ifdef CONFIG_CPU_FREQ
 161     struct notifier_block freq_transition;
 162 #endif
 163
 164 };
 165
 166 typedef enum _TRSP_MODE
 167 {
 168     TRSP_CLOSE = 0,
 169     TRSP_FMREG,
 170     TRSP_FMREGEX,
 171     TRSP_FMRAM,
 172     TRSP_FMRAMEX,
 173     TRSP_MASK,
 174     TRSP_INVAL
 175 } TRSP_MODE;
 176
 177
 178 struct platform_device *g_pdev = NULL;
 179 static int win1fb_set_par(struct fb_info *info);
 180
 181 #if 0
 182 #define CHK_SUSPEND(inf)        \
 183         if(inf->in_suspend)     {       \
 184                 fbprintk(">>>>>> fb is in suspend! return! \n");        \
 185                 return -EPERM;  \
 186         }
 187 #else
 188 #define CHK_SUSPEND(inf)
 189 #endif
 190
 191 static DECLARE_WAIT_QUEUE_HEAD(wq);
 192 static int wq_condition = 0;
 193
 194 #if ANDROID_USE_THREE_BUFS
 195 static int new_frame_seted = 1;
 196 #endif
 197
 198 void set_lcd_pin(struct platform_device *pdev, int enable)
 199 {
 200         struct rk29fb_info *mach_info = pdev->dev.platform_data;
 201
 202         unsigned display_on = mach_info->disp_on_pin;
 203         unsigned lcd_standby = mach_info->standby_pin;
 204
 205         int display_on_pol = mach_info->disp_on_value;
 206         int lcd_standby_pol = mach_info->standby_value;
 207
 208         fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
 209         fbprintk(">>>>>> display_on(%d) = %d \n", display_on, enable ? display_on_pol : !display_on_pol);
 210         fbprintk(">>>>>> lcd_standby(%d) = %d \n", lcd_standby, enable ? lcd_standby_pol : !lcd_standby_pol);
 211
 212     // set display_on
 213
 214     if(display_on != INVALID_GPIO)
 215     {
 216         gpio_direction_output(display_on, 0);
 217                 gpio_set_value(display_on, enable ? display_on_pol : !display_on_pol);
 218     }
 219     if(lcd_standby != INVALID_GPIO)
 220     {
 221         gpio_direction_output(lcd_standby, 0);
 222                 gpio_set_value(lcd_standby, enable ? lcd_standby_pol : !lcd_standby_pol);
 223     }
 224 }
 225
 226 int mcu_do_refresh(struct rk29fb_inf *inf)
 227 {
 228     if(inf->mcu_stopflush)  return 0;
 229
 230     if(SCREEN_MCU!=inf->cur_screen->type)   return 0;
 231
 232     // use frame mark
 233     if(IsMcuUseFmk())
 234     {
 235         inf->mcu_needflush = 1;
 236         return 0;
 237     }
 238
 239     // not use frame mark
 240     if(LcdReadBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_SELECT))
 241     {
 242         if(!LcdReadBit(inf, MCU_TIMING_CTRL, m_MCU_HOLD_STATUS))
 243         {
 244             inf->mcu_needflush = 1;
 245         }
 246         else
 247         {
 248             if(inf->cur_screen->refresh)    inf->cur_screen->refresh(REFRESH_PRE);
 249             inf->mcu_needflush = 0;
 250             inf->mcu_isrcnt = 0;
 251             LcdSetRegBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST);
 252         }
 253     }
 254     return 0;
 255 }
 256
 257
 258 void mcutimer_callback(unsigned long arg)
 259 {
 260     struct rk29fb_inf *inf = platform_get_drvdata(g_pdev);
 261     static int waitcnt = 0;
 262
 263     mod_timer(&inf->mcutimer, jiffies + HZ/10);
 264
 265     switch(inf->mcu_status)
 266     {
 267     case MS_IDLE:
 268         inf->mcu_status = MS_MCU;
 269         break;
 270     case MS_MCU:
 271         if(inf->mcu_usetimer)   mcu_do_refresh(inf);
 272         break;
 273     case MS_EWAITSTART:
 274         inf->mcu_status = MS_EWAITEND;
 275         waitcnt = 0;
 276         break;
 277     case MS_EWAITEND:
 278         if(0==waitcnt) {
 279             mcu_do_refresh(inf);
 280         }
 281         if(waitcnt++>14) {
 282             inf->mcu_status = MS_EEND;
 283         }
 284         break;
 285     case MS_EEND:
 286         inf->mcu_status = MS_MCU;
 287         break;
 288     default:
 289         inf->mcu_status = MS_MCU;
 290         break;
 291     }
 292 }
 293
 294 int mcu_refresh(struct rk29fb_inf *inf)
 295 {
 296     static int mcutimer_inited = 0;
 297
 298     if(SCREEN_MCU!=inf->cur_screen->type)   return 0;
 299
 300     if(!mcutimer_inited)
 301     {
 302         mcutimer_inited = 1;
 303         init_timer(&inf->mcutimer);
 304         inf->mcutimer.function = mcutimer_callback;
 305         inf->mcutimer.expires = jiffies + HZ/5;
 306         inf->mcu_status = MS_IDLE;
 307         add_timer(&inf->mcutimer);
 308     }
 309
 310     if(MS_MCU==inf->mcu_status)     mcu_do_refresh(inf);
 311
 312     return 0;
 313 }
 314
 315 int mcu_ioctl(unsigned int cmd, unsigned long arg)
 316 {
 317     struct rk29fb_inf *inf = NULL;
 318     if(!g_pdev)     return -1;
 319
 320     inf = dev_get_drvdata(&g_pdev->dev);
 321
 322     switch(cmd)
 323     {
 324     case MCU_WRCMD:
 325         LcdClrBit(inf, MCU_TIMING_CTRL, m_MCU_RS_SELECT);
 326         LcdWrReg(inf, MCU_BYPASS_WPORT, arg);
 327         LcdSetBit(inf, MCU_TIMING_CTRL, m_MCU_RS_SELECT);
 328         break;
 329
 330     case MCU_WRDATA:
 331         LcdSetBit(inf, MCU_TIMING_CTRL, m_MCU_RS_SELECT);
 332         LcdWrReg(inf, MCU_BYPASS_WPORT, arg);
 333         break;
 334
 335     case MCU_SETBYPASS:
 336         LcdMskReg(inf, MCU_TIMING_CTRL, m_MCU_BYPASSMODE_SELECT, v_MCU_BYPASSMODE_SELECT(arg));
 337         LcdWrReg(inf, REG_CFG_DONE, 0x01);
 338         break;
 339
 340     default:
 341         break;
 342     }
 343
 344     return 0;
 345 }
 346
 347 static irqreturn_t mcu_irqfmk(int irq, void *dev_id)
 348 {
 349         struct platform_device *pdev = (struct platform_device*)dev_id;
 350     struct rk29fb_inf *inf = platform_get_drvdata(pdev);
 351     struct rk29fb_screen *screen;
 352
 353     if(!inf)    return IRQ_HANDLED;
 354
 355     screen = inf->cur_screen;
 356
 357     if(0==screen->mcu_usefmk) {
 358         return IRQ_HANDLED;
 359     }
 360
 361     if(inf->mcu_fmksync == 1)
 362         return IRQ_HANDLED;
 363
 364     inf->mcu_fmksync = 1;
 365     if(inf->mcu_needflush)
 366     {
 367         inf->mcu_needflush = 0;
 368         inf->mcu_isrcnt = 0;
 369         if(inf->cur_screen->refresh)
 370            inf->cur_screen->refresh(REFRESH_PRE);
 371         LcdSetBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST);
 372     }
 373     inf->mcu_fmksync = 0;
 374
 375         return IRQ_HANDLED;
 376 }
 377
 378 int init_lcdc(struct fb_info *info)
 379 {
 380     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
 381     u32 msk=0, clr=0;
 382
 383         fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
 384
 385         // set AHB access rule and disable all windows
 386     LcdWrReg(inf, SYS_CONFIG, 0x20000000);
 387     LcdWrReg(inf, SWAP_CTRL, 0);
 388     LcdWrReg(inf, FIFO_WATER_MARK, 0x00000860);
 389
 390         // and mcu holdmode; and set win1 top.
 391     LcdMskReg(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_SELECT | m_MCU_HOLDMODE_FRAME_ST | m_MCU_BYPASSMODE_SELECT ,
 392             v_MCU_HOLDMODE_SELECT(0)| v_MCU_HOLDMODE_FRAME_ST(0) |v_MCU_BYPASSMODE_SELECT(0));
 393
 394     // disable blank out, black out, tristate out, yuv2rgb bypass
 395     LcdMskReg(inf, BLEND_CTRL,m_W2_BLEND_EN | m_W1_BLEND_EN | m_W0_BLEND_EN | m_HWC_BLEND_EN |
 396              m_HWC_BLEND_FACTOR | m_W1_BLEND_FACTOR | m_W0_BLEND_FACTOR,
 397              v_W2_BLEND_EN(0) |v_W1_BLEND_EN(0) | v_W0_BLEND_EN(0) | v_HWC_BLEND_EN(0) |
 398              v_HWC_BLEND_FACTOR(0) | v_W2_BLEND_FACTOR(0) | v_W1_BLEND_FACTOR(0) | v_W0_BLEND_FACTOR(0)
 399              );
 400
 401     LcdMskReg(inf, WIN0_COLOR_KEY_CTRL, m_COLORKEY_EN, v_COLORKEY_EN(0));
 402     LcdMskReg(inf, WIN1_COLOR_KEY_CTRL, m_COLORKEY_EN, v_COLORKEY_EN(0));
 403
 404     LcdWrReg(inf, DSP_CTRL1, 0);
 405
 406     // initialize all interrupt
 407     clr = v_HOR_STARTCLEAR(1) | v_FRM_STARTCLEAR(1) | v_SCANNING_CLEAR(1);
 408
 409     msk = v_HOR_STARTMASK(1) | v_FRM_STARTMASK(0) | v_SCANNING_MASK(1);
 410
 411     LcdWrReg(inf, INT_STATUS, clr | msk);
 412
 413         // let above to take effect
 414     LcdWrReg(inf, REG_CFG_DONE, 0x01);
 415
 416     return 0;
 417 }
 418
 419 void load_screen(struct fb_info *info, bool initscreen)
 420 {
 421     int ret = -EINVAL;
 422     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
 423     struct rk29fb_screen *screen = inf->cur_screen;
 424     u16 face;
 425     u16 mcu_total, mcu_rwstart, mcu_csstart, mcu_rwend, mcu_csend;
 426     u16 right_margin = screen->right_margin, lower_margin = screen->lower_margin;
 427     u16 x_res = screen->x_res, y_res = screen->y_res;
 428     u32 aclk_rate = 150000000;
 429
 430     if(!g_pdev){
 431         printk(">>>>>> %s : %s no g_pdev\n", __FILE__, __FUNCTION__);
 432         return;
 433     }
 434
 435         fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
 436
 437     // set the rgb or mcu
 438     LcdMskReg(inf, MCU_TIMING_CTRL, m_MCU_OUTPUT_SELECT, v_MCU_OUTPUT_SELECT((SCREEN_MCU==screen->type)?(1):(0)));
 439
 440         // set out format and mcu timing
 441     mcu_total  = (screen->mcu_wrperiod*150*1000)/1000000;
 442     if(mcu_total>31)    mcu_total = 31;
 443     if(mcu_total<3)     mcu_total = 3;
 444     mcu_rwstart = (mcu_total+1)/4 - 1;
 445     mcu_rwend = ((mcu_total+1)*3)/4 - 1;
 446     mcu_csstart = (mcu_rwstart>2) ? (mcu_rwstart-3) : (0);
 447     mcu_csend = (mcu_rwend>15) ? (mcu_rwend-1) : (mcu_rwend);
 448
 449     fbprintk(">> mcu_total=%d, mcu_rwstart=%d, mcu_csstart=%d, mcu_rwend=%d, mcu_csend=%d \n",
 450         mcu_total, mcu_rwstart, mcu_csstart, mcu_rwend, mcu_csend);
 451
 452     LcdMskReg(inf, MCU_TIMING_CTRL,
 453              m_MCU_CS_ST | m_MCU_CS_END| m_MCU_RW_ST | m_MCU_RW_END |
 454              m_MCU_WRITE_PERIOD | m_MCU_HOLDMODE_SELECT | m_MCU_HOLDMODE_FRAME_ST,
 455             v_MCU_CS_ST(mcu_csstart) | v_MCU_CS_END(mcu_csend) | v_MCU_RW_ST(mcu_rwstart) |
 456             v_MCU_RW_END(mcu_rwend) |  v_MCU_WRITE_PERIOD(mcu_total) |
 457             v_MCU_HOLDMODE_SELECT((SCREEN_MCU==screen->type)?(1):(0)) | v_MCU_HOLDMODE_FRAME_ST(0)
 458            );
 459
 460         // set synchronous pin polarity and data pin swap rule
 461         switch (screen->face)
 462         {
 463         case OUT_P565:
 464             face = OUT_P565;
 465             LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
 466             break;
 467         case OUT_P666:
 468             face = OUT_P666;
 469             LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
 470             break;
 471         case OUT_D888_P565:
 472             face = OUT_P888;
 473             LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
 474             break;
 475         case OUT_D888_P666:
 476             face = OUT_P888;
 477             LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
 478             break;
 479         case OUT_P888:
 480             face = OUT_P888;
 481             LcdMskReg(inf, DSP_CTRL0, m_DITHER_UP_EN, v_DITHER_UP_EN(1));
 482             break;
 483         default:
 484             face = screen->face;
 485             break;
 486     }
 487
 488      LcdMskReg(inf, DSP_CTRL0,
 489         m_DISPLAY_FORMAT | m_HSYNC_POLARITY | m_VSYNC_POLARITY | m_DEN_POLARITY |
 490         m_DCLK_POLARITY | m_COLOR_SPACE_CONVERSION,
 491         v_DISPLAY_FORMAT(face) | v_HSYNC_POLARITY(screen->pin_hsync) | v_VSYNC_POLARITY(screen->pin_vsync) |
 492         v_DEN_POLARITY(screen->pin_den) | v_DCLK_POLARITY(screen->pin_dclk) | v_COLOR_SPACE_CONVERSION(0)
 493         );
 494
 495      LcdMskReg(inf, DSP_CTRL1, m_BG_COLOR,  v_BG_COLOR(0x000000) );
 496
 497      LcdMskReg(inf, SWAP_CTRL, m_OUTPUT_RB_SWAP | m_OUTPUT_RG_SWAP | m_DELTA_SWAP | m_DUMMY_SWAP,
 498             v_OUTPUT_RB_SWAP(screen->swap_rb) | v_OUTPUT_RG_SWAP(screen->swap_rg) | v_DELTA_SWAP(screen->swap_delta) | v_DUMMY_SWAP(screen->swap_dumy));
 499
 500         // set horizontal & vertical out timing
 501         if(SCREEN_MCU==inf->cur_screen->type)
 502     {
 503             right_margin = x_res/6;
 504         }
 505
 506     printk("screen->hsync_len =%d,  screen->left_margin =%d, x_res =%d,  right_margin = %d \n",
 507         screen->hsync_len , screen->left_margin , x_res , right_margin );
 508     LcdMskReg(inf, DSP_HTOTAL_HS_END, m_BIT11LO | m_BIT11HI, v_BIT11LO(screen->hsync_len) |
 509              v_BIT11HI(screen->hsync_len + screen->left_margin + x_res + right_margin));
 510     LcdMskReg(inf, DSP_HACT_ST_END, m_BIT11LO | m_BIT11HI, v_BIT11LO(screen->hsync_len + screen->left_margin + x_res) |
 511              v_BIT11HI(screen->hsync_len + screen->left_margin));
 512
 513     LcdMskReg(inf, DSP_VTOTAL_VS_END, m_BIT11LO | m_BIT11HI, v_BIT11LO(screen->vsync_len) |
 514               v_BIT11HI(screen->vsync_len + screen->upper_margin + y_res + lower_margin));
 515     LcdMskReg(inf, DSP_VACT_ST_END, m_BIT11LO | m_BIT11HI,  v_BIT11LO(screen->vsync_len + screen->upper_margin+y_res)|
 516               v_BIT11HI(screen->vsync_len + screen->upper_margin));
 517
 518     LcdMskReg(inf, DSP_VS_ST_END_F1, m_BIT11LO | m_BIT11HI, v_BIT11LO(0) | v_BIT11HI(0));
 519     LcdMskReg(inf, DSP_VACT_ST_END_F1, m_BIT11LO | m_BIT11HI, v_BIT11LO(0) | v_BIT11HI(0));
 520
 521         // let above to take effect
 522     LcdWrReg(inf, REG_CFG_DONE, 0x01);
 523
 524     inf->clk = clk_get(&g_pdev->dev, "hclk_lcdc");
 525     if (!inf->clk || IS_ERR(inf->clk))
 526     {
 527         printk(KERN_ERR "failed to get lcdc_hclk source\n");
 528         return ;
 529     }
 530
 531     inf->dclk = clk_get(&g_pdev->dev, "dclk_lcdc");
 532         if (!inf->dclk || IS_ERR(inf->dclk))
 533     {
 534                 printk(KERN_ERR "failed to get lcd dclock source\n");
 535                 return ;
 536         }
 537     inf->dclk_divider= clk_get(&g_pdev->dev, "dclk_lcdc_div");
 538     if (!inf->dclk_divider || IS_ERR(inf->dclk_divider))
 539     {
 540                 printk(KERN_ERR "failed to get lcd clock lcdc_divider source \n");
 541                 return ;
 542         }
 543
 544     if(inf->cur_screen == &inf->lcd_info)    {
 545         inf->dclk_parent = clk_get(&g_pdev->dev, "periph_pll");
 546     }    else    {
 547         inf->dclk_parent = clk_get(&g_pdev->dev, "codec_pll");
 548     }
 549
 550     if (!inf->dclk_parent || IS_ERR(inf->dclk_parent))
 551     {
 552                 printk(KERN_ERR "failed to get lcd dclock parent source\n");
 553                 return ;
 554         }
 555
 556     inf->aclk = clk_get(&g_pdev->dev, "aclk_lcdc");
 557     if (!inf->aclk || IS_ERR(inf->aclk))
 558     {
 559                 printk(KERN_ERR "failed to get lcd clock clk_share_mem source \n");
 560                 return ;
 561         }
 562     inf->aclk_parent = clk_get(&g_pdev->dev, "periph_pll");
 563     if (!inf->dclk_parent || IS_ERR(inf->dclk_parent))
 564     {
 565                 printk(KERN_ERR "failed to get lcd dclock parent source\n");
 566                 return ;
 567         }
 568
 569     // set lcdc clk
 570     if(SCREEN_MCU==screen->type)    screen->pixclock = 150000000; //mcu fix to 150 MHz
 571
 572     if(initscreen == 0)    //not init
 573     {
 574         clk_disable(inf->dclk);
 575         clk_disable(inf->clk);
 576         clk_disable(inf->aclk);
 577     }
 578
 579     clk_set_parent(inf->dclk_divider, inf->dclk_parent);
 580     clk_set_parent(inf->dclk, inf->dclk_divider);
 581     clk_set_parent(inf->aclk, inf->aclk_parent);
 582
 583     fbprintk(">>>>>> set lcdc dclk need %d HZ, clk_parent = %d hz \n ", screen->pixclock, clk_rate);
 584
 585     ret = clk_set_rate(inf->dclk_divider, screen->pixclock);
 586     if(ret)
 587     {
 588         printk(KERN_ERR ">>>>>> set lcdc dclk_divider faild \n ");
 589     }
 590
 591     if(screen->lcdc_aclk){
 592         aclk_rate = screen->lcdc_aclk;
 593     }
 594     ret = clk_set_rate(inf->aclk, aclk_rate);
 595     if(ret){
 596         printk(KERN_ERR ">>>>>> set lcdc dclk_divider faild \n ");
 597     }
 598
 599     clk_enable(inf->dclk);
 600     clk_enable(inf->clk);
 601     clk_enable(inf->aclk);
 602
 603     // init screen panel
 604     if(screen->init)
 605     {
 606         screen->init();
 607     }
 608
 609 }
 610 #ifdef CONFIG_CPU_FREQ
 611 /*
 612 * CPU clock speed change handler. We need to adjust the LCD timing
 613 * parameters when the CPU clock is adjusted by the power management
 614 * subsystem.
 615 */
 616 #define TO_INF(ptr,member) container_of(ptr,struct rk29fb_inf,member)
 617
 618 static int
 619 rk29fb_freq_transition(struct notifier_block *nb, unsigned long val, void *data)
 620 {
 621     struct rk29fb_inf *inf = TO_INF(nb, freq_transition);
 622     struct rk29fb_screen *screen = inf->cur_screen;
 623     u32 dclk_rate = 0;
 624
 625     switch (val)
 626     {
 627     case CPUFREQ_PRECHANGE:
 628           break;
 629     case CPUFREQ_POSTCHANGE:
 630         {
 631          dclk_rate = screen->pixclock * 1000000;
 632
 633          fbprintk(">>>>>> set lcdc dclk need %d HZ, clk_parent = %d hz \n ", screen->pixclock, dclk_rate);
 634
 635          clk_set_rate(inf->dclk_divider, dclk_rate);
 636          break;
 637         }
 638     }
 639     return 0;
 640 }
 641 #endif
 642
 643 static inline unsigned int chan_to_field(unsigned int chan,
 644                                          struct fb_bitfield *bf)
 645 {
 646         chan &= 0xffff;
 647         chan >>= 16 - bf->length;
 648         return chan << bf->offset;
 649 }
 650
 651 static int fb_setcolreg(unsigned regno,
 652                                unsigned red, unsigned green, unsigned blue,
 653                                unsigned transp, struct fb_info *info)
 654 {
 655         unsigned int val;
 656 //      fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
 657
 658         switch (info->fix.visual) {
 659         case FB_VISUAL_TRUECOLOR:
 660                 /* true-colour, use pseudo-palette */
 661                 if (regno < 16) {
 662                         u32 *pal = info->pseudo_palette;
 663                         val  = chan_to_field(red,   &info->var.red);
 664                         val |= chan_to_field(green, &info->var.green);
 665                         val |= chan_to_field(blue,  &info->var.blue);
 666                         pal[regno] = val;
 667                 }
 668                 break;
 669         default:
 670                 return -1;      /* unknown type */
 671         }
 672
 673         return 0;
 674 }
 675 #if 0
 676
 677 int rk29_set_cursor(struct fb_info *info, struct fb_cursor *cursor)
 678 {
 679     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
 680
 681     //fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
 682
 683     /* check not being asked to exceed capabilities */
 684
 685     if (cursor->image.width > 32)
 686         return -EINVAL;
 687
 688     if (cursor->image.height > 32)
 689         return -EINVAL;
 690
 691     if (cursor->image.depth > 1)
 692         return -EINVAL;
 693
 694     if (cursor->enable)
 695         LcdSetBit(inf, SYS_CONFIG, m_HWC_ENABLE);
 696     else
 697         LcdClrBit(inf, SYS_CONFIG, m_HWC_ENABLE);
 698
 699     /* set data */
 700     if (cursor->set & FB_CUR_SETPOS)
 701     {
 702         unsigned int x = cursor->image.dx;
 703         unsigned int y = cursor->image.dy;
 704
 705         if (x >= 0x800 || y >= 0x800 )
 706             return -EINVAL;
 707         LcdWrReg(inf, HWC_DSP_ST, v_BIT11LO(x)|v_BIT11HI(y));
 708     }
 709
 710
 711     if (cursor->set & FB_CUR_SETCMAP)
 712     {
 713         unsigned int bg_col = cursor->image.bg_color;
 714         unsigned int fg_col = cursor->image.fg_color;
 715
 716         fbprintk("%s: update cmap (%08x,%08x)\n",
 717             __func__, bg_col, fg_col);
 718
 719         LcdMskReg(inf, HWC_COLOR_LUT0, m_HWC_R|m_HWC_G|m_HWC_B,
 720                   v_HWC_R(info->cmap.red[bg_col]>>8) | v_HWC_G(info->cmap.green[bg_col]>>8) | v_HWC_B(info->cmap.blue[bg_col]>>8));
 721
 722         LcdMskReg(inf, HWC_COLOR_LUT2, m_HWC_R|m_HWC_G|m_HWC_B,
 723                          v_HWC_R(info->cmap.red[fg_col]>>8) | v_HWC_G(info->cmap.green[fg_col]>>8) | v_HWC_B(info->cmap.blue[fg_col]>>8));
 724     }
 725
 726     if ((cursor->set & FB_CUR_SETSIZE ||
 727         cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE))
 728         && info->screen_base && info->fix.smem_start && info->fix.smem_len)
 729     {
 730         /* rk29 cursor is a 2 bpp 32x32 bitmap this routine
 731          * clears it to transparent then combines the cursor
 732          * shape plane with the colour plane to set the
 733          * cursor */
 734         int x, y;
 735         const unsigned char *pcol = cursor->image.data;
 736         const unsigned char *pmsk = cursor->mask;
 737         void __iomem   *dst;
 738         unsigned long cursor_mem_start;
 739         unsigned char  dcol = 0;
 740         unsigned char  dmsk = 0;
 741         unsigned int   op;
 742
 743         dst = info->screen_base + info->fix.smem_len - CURSOR_BUF_SIZE;
 744             cursor_mem_start = info->fix.smem_start + info->fix.smem_len - CURSOR_BUF_SIZE;
 745
 746         fbprintk("%s: setting shape (%d,%d)\n",
 747             __func__, cursor->image.width, cursor->image.height);
 748
 749         memset(dst, 0, CURSOR_BUF_SIZE);
 750
 751         for (y = 0; y < cursor->image.height; y++)
 752         {
 753             for (x = 0; x < cursor->image.width; x++)
 754             {
 755                 if ((x % 8) == 0) {
 756                     dcol = *pcol++;
 757                     dmsk = *pmsk++;
 758                 } else {
 759                     dcol >>= 1;
 760                     dmsk >>= 1;
 761                 }
 762
 763                 if (dmsk & 1) {
 764                     op = (dcol & 1) ? 1 : 3;
 765                     op <<= ((x % 4) * 2);
 766                     *(u8*)(dst+(x/4)) |= op;
 767                 }
 768             }
 769             dst += (32*2)/8;
 770         }
 771         LcdSetBit(inf, SYS_CONFIG,m_HWC_RELOAD_EN);
 772         LcdWrReg(inf, HWC_MST, cursor_mem_start);
 773         // flush end when wq_condition=1 in mcu panel, but not in rgb panel
 774         if(SCREEN_MCU == inf->cur_screen->type) {
 775             wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
 776             wq_condition = 0;
 777         } else {
 778             wq_condition = 0;
 779             wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
 780         }
 781         LcdClrBit(inf, SYS_CONFIG, m_HWC_RELOAD_EN);
 782     }
 783
 784     return 0;
 785 }
 786 #endif
 787
 788 static int win0fb_blank(int blank_mode, struct fb_info *info)
 789 {
 790     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
 791
 792     fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
 793
 794         CHK_SUSPEND(inf);
 795
 796     switch(blank_mode)
 797     {
 798     case FB_BLANK_UNBLANK:
 799         LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(1));
 800         break;
 801     default:
 802         LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(0));
 803         break;
 804     }
 805     LcdWrReg(inf, REG_CFG_DONE, 0x01);
 806
 807         mcu_refresh(inf);
 808     return 0;
 809 }
 810
 811 static int win0fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 812 {
 813     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
 814     struct rk29fb_screen *screen = inf->cur_screen;
 815
 816     u32 ScaleYRGBY=0x1000;
 817     u16 xpos = (var->nonstd>>8) & 0xfff;   //offset in panel
 818     u16 ypos = (var->nonstd>>20) & 0xfff;
 819     u16 xsize = (var->grayscale>>8) & 0xfff;   //visiable size in panel
 820     u16 ysize = (var->grayscale>>20) & 0xfff;
 821     u16 xlcd = screen->x_res;        //size of panel
 822     u16 ylcd = screen->y_res;
 823     u16 yres = 0;
 824
 825     if(inf->win0fb->var.rotate == 270) {
 826         xlcd = screen->y_res;
 827         ylcd = screen->x_res;
 828     }
 829
 830     fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
 831
 832         CHK_SUSPEND(inf);
 833
 834     if( 0==var->xres_virtual || 0==var->yres_virtual ||
 835         0==var->xres || 0==var->yres || var->xres<16 ||
 836         0==xsize || 0==ysize || xsize<16 ||
 837         ((16!=var->bits_per_pixel)&&(32!=var->bits_per_pixel)) )
 838     {
 839         printk(">>>>>> win0fb_check_var fail 1!!! \n");
 840                 printk("0==%d || 0==%d || 0==%d || 0==%d || %d<16 \n ||0==%d || 0==%d || %d<16 ||((16!=%d)&&(32!=%d)) \n",
 841                                 var->xres_virtual, var->yres_virtual, var->xres, var->yres, var->xres, xsize, ysize, xsize,
 842                         var->bits_per_pixel, var->bits_per_pixel);
 843         return -EINVAL;
 844     }
 845
 846     if( (var->xoffset+var->xres)>var->xres_virtual ||
 847         (var->yoffset+var->yres)>var->yres_virtual ||
 848         (xpos+xsize)>xlcd || (ypos+ysize)>ylcd )
 849     {
 850         printk(">>>>>> win0fb_check_var fail 2!!! \n");
 851                 printk("(%d+%d)>%d || (%d+%d)>%d || (%d+%d)>%d || (%d+%d)>%d \n ",
 852                                 var->xoffset, var->xres, var->xres_virtual, var->yoffset, var->yres,
 853                                 var->yres_virtual, xpos, xsize, xlcd, ypos, ysize, ylcd);
 854         return -EINVAL;
 855     }
 856
 857     switch(var->nonstd&0x0f)
 858     {
 859     case 0: // rgb
 860         switch(var->bits_per_pixel)
 861         {
 862         case 16:    // rgb565
 863             var->xres_virtual = (var->xres_virtual + 0x1) & (~0x1);
 864             var->xres = (var->xres + 0x1) & (~0x1);
 865             var->xoffset = (var->xoffset) & (~0x1);
 866             break;
 867         default:    // rgb888
 868             var->bits_per_pixel = 32;
 869             break;
 870         }
 871         var->nonstd &= ~0xc0;  //not support I2P in this format
 872         break;
 873     case 1: // yuv422
 874         var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
 875         var->xres = (var->xres + 0x3) & (~0x3);
 876         var->xoffset = (var->xoffset) & (~0x3);
 877         break;
 878     case 2: // yuv4200
 879         var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
 880         var->yres_virtual = (var->yres_virtual + 0x1) & (~0x1);
 881         var->xres = (var->xres + 0x3) & (~0x3);
 882         var->yres = (var->yres + 0x1) & (~0x1);
 883         var->xoffset = (var->xoffset) & (~0x3);
 884         var->yoffset = (var->yoffset) & (~0x1);
 885         break;
 886     case 3: // yuv4201
 887         var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
 888         var->yres_virtual = (var->yres_virtual + 0x1) & (~0x1);
 889         var->xres = (var->xres + 0x3) & (~0x3);
 890         var->yres = (var->yres + 0x1) & (~0x1);
 891         var->xoffset = (var->xoffset) & (~0x3);
 892         var->yoffset = (var->yoffset) & (~0x1);
 893         var->nonstd &= ~0xc0;   //not support I2P in this format
 894         break;
 895     case 4: // none
 896     case 5: // yuv444
 897         var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
 898         var->xres = (var->xres + 0x3) & (~0x3);
 899         var->xoffset = (var->xoffset) & (~0x3);
 900         var->nonstd &= ~0xc0;   //not support I2P in this format
 901         break;
 902     default:
 903         printk(">>>>>> win0fb var->nonstd=%d is invalid! \n", var->nonstd);
 904         return -EINVAL;
 905     }
 906
 907     if(var->rotate == 270)
 908     {
 909         yres = var->xres;
 910     }
 911     else
 912     {
 913         yres = var->yres;
 914     }
 915     ScaleYRGBY = CalScaleW0(yres, ysize);
 916
 917     if((ScaleYRGBY>0x8000) || (ScaleYRGBY<0x200))
 918     {
 919         return -EINVAL;        // multiple of scale down or scale up can't exceed 8
 920     }
 921
 922     return 0;
 923 }
 924
 925 static int win0fb_set_par(struct fb_info *info)
 926 {
 927     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
 928     struct rk29fb_screen *screen = inf->cur_screen;
 929     struct fb_var_screeninfo *var = &info->var;
 930     struct fb_fix_screeninfo *fix = &info->fix;
 931     struct win0_par *par = info->par;
 932
 933     u8 format = 0;
 934     u32 cblen=0, crlen=0, map_size=0, smem_len=0;
 935
 936         u32 xact = var->xres;                       /* visible resolution               */
 937         u32 yact = var->yres;
 938         u32 xvir = var->xres_virtual;           /* virtual resolution           */
 939         u32 yvir = var->yres_virtual;
 940         u32 xact_st = var->xoffset;                     /* offset from virtual to visible */
 941         u32 yact_st = var->yoffset;                     /* resolution                   */
 942
 943     u16 xpos = (var->nonstd>>8) & 0xfff;      //visiable pos in panel
 944     u16 ypos = (var->nonstd>>20) & 0xfff;
 945     u16 xsize = (var->grayscale>>8) & 0xfff;  //visiable size in panel
 946     u16 ysize = (var->grayscale>>20) & 0xfff;
 947
 948     u32 ScaleYrgbX=0x1000,ScaleYrgbY=0x1000;
 949     u32 ScaleCbrX=0x1000, ScaleCbrY=0x1000;
 950
 951     u8 data_format = var->nonstd&0x0f;
 952     u32 win0_en = var->reserved[2];
 953     u32 y_addr = var->reserved[3];       //user alloc buf addr y
 954     u32 uv_addr = var->reserved[4];
 955
 956     fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
 957
 958         CHK_SUSPEND(inf);
 959
 960         /* calculate y_offset,uv_offset,line_length,cblen and crlen  */
 961     switch (data_format)
 962     {
 963     case 0: // rgb
 964         switch(var->bits_per_pixel)
 965         {
 966         case 16:    // rgb565
 967             format = 1;
 968             fix->line_length = 2 * xvir;
 969             par->y_offset = (yact_st*xvir + xact_st)*2;
 970             break;
 971         case 32:    // rgb888
 972             format = 0;
 973             fix->line_length = 4 * xvir;
 974             par->y_offset = (yact_st*xvir + xact_st)*4;
 975             break;
 976         default:
 977             return -EINVAL;
 978         }
 979         break;
 980     case 1: // yuv422
 981         format = 2;
 982         fix->line_length = xvir;
 983         cblen = crlen = (xvir*yvir)/2;
 984         par->y_offset = yact_st*xvir + xact_st;
 985         par->uv_offset = yact_st*xvir + xact_st;
 986         break;
 987     case 2: // yuv4200
 988         format = 3;
 989         fix->line_length = xvir;
 990         cblen = crlen = (xvir*yvir)/4;
 991
 992         par->y_offset = yact_st*xvir + xact_st;
 993         par->uv_offset = (yact_st/2)*xvir + xact_st;
 994
 995         break;
 996     case 3: // yuv4201
 997         format = 4;
 998         fix->line_length = xvir;
 999         par->y_offset = (yact_st/2)*2*xvir + (xact_st)*2;
1000         par->uv_offset = (yact_st/2)*xvir + xact_st;
1001         cblen = crlen = (xvir*yvir)/4;
1002         break;
1003     case 4: // none
1004     case 5: // yuv444
1005         format = 5;
1006         fix->line_length = xvir;
1007         par->y_offset = yact_st*xvir + xact_st;
1008         par->uv_offset = yact_st*2*xvir + xact_st*2;
1009         cblen = crlen = (xvir*yvir);
1010         break;
1011     default:
1012         return -EINVAL;
1013     }
1014
1015     smem_len = fix->line_length * yvir + cblen + crlen;
1016     map_size = PAGE_ALIGN(smem_len);
1017
1018     if (info->screen_base) {
1019         printk(">>>>>> win0fb unmap memory(%d)! \n", info->fix.smem_len);
1020         dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len),info->screen_base, info->fix.smem_start);
1021         info->screen_base = 0;
1022     }
1023     fix->smem_start = y_addr;
1024     fix->smem_len = smem_len;
1025     fix->mmio_start = uv_addr;
1026
1027     par->addr_seted = (((-1==(int)y_addr)&&(-1==(int)uv_addr))||((0==(int)y_addr)&&(0==(int)uv_addr))) ? 0 : 1;
1028     fbprintk("buffer alloced by user fix->smem_start = %8x, fix->smem_len = %8x, fix->mmio_start = %8x \n", (u32)fix->smem_start, (u32)fix->smem_len, (u32)fix->mmio_start);
1029
1030         // calculate the display phy address
1031     y_addr = fix->smem_start + par->y_offset;
1032     uv_addr = fix->mmio_start + par->uv_offset;
1033
1034     fbprintk("y_addr 0x%08x = 0x%08x + %d\n", y_addr, (u32)fix->smem_start, par->y_offset);
1035     fbprintk("uv_addr 0x%08x = 0x%08x + %d\n", uv_addr, (u32)fix->mmio_start , par->uv_offset);
1036
1037     ScaleYrgbX = CalScaleW0(xact, xsize);
1038     ScaleYrgbY = CalScaleW0(yact, ysize);
1039
1040     switch (data_format)
1041     {
1042        case 1:// yuv422
1043            ScaleCbrX= CalScaleW0((xact/2), xsize);
1044            ScaleCbrY =  CalScaleW0(yact, ysize);
1045            break;
1046        case 2: // yuv4200
1047        case 3: // yuv4201
1048            ScaleCbrX= CalScaleW0(xact/2, xsize);
1049            ScaleCbrY =  CalScaleW0(yact/2, ysize);
1050            break;
1051        case 4: // none
1052        case 5:// yuv444
1053            ScaleCbrX= CalScaleW0(xact, xsize);
1054            ScaleCbrY =  CalScaleW0(yact, ysize);
1055            break;
1056     }
1057
1058     xpos += (screen->left_margin + screen->hsync_len);
1059     ypos += (screen->upper_margin + screen->vsync_len);
1060
1061     LcdWrReg(inf, WIN0_YRGB_MST, y_addr);
1062     LcdWrReg(inf, WIN0_CBR_MST, uv_addr);
1063
1064     LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE | m_W0_FORMAT, v_W0_ENABLE(win0_en && par->addr_seted) | v_W0_FORMAT(format));
1065
1066     LcdMskReg(inf, WIN0_VIR, m_WORDLO | m_WORDHI, v_VIRWIDTH(xvir) | v_VIRHEIGHT((yvir)) );
1067     LcdMskReg(inf, WIN0_ACT_INFO, m_WORDLO | m_WORDHI, v_WORDLO(xact) | v_WORDHI(yact));
1068     LcdMskReg(inf, WIN0_DSP_ST, m_BIT11LO | m_BIT11HI, v_BIT11LO(xpos) | v_BIT11HI(ypos));
1069     LcdMskReg(inf, WIN0_DSP_INFO, m_BIT11LO | m_BIT11HI,  v_BIT11LO(xsize) | v_BIT11HI(ysize));
1070     LcdMskReg(inf, WIN0_SCL_FACTOR_YRGB, m_WORDLO | m_WORDHI, v_WORDLO(ScaleYrgbX) | v_WORDHI(ScaleYrgbY));
1071     LcdMskReg(inf, WIN0_SCL_FACTOR_CBR, m_WORDLO | m_WORDHI, v_WORDLO(ScaleCbrX) | v_WORDHI(ScaleCbrY));
1072
1073     switch(format)
1074     {
1075     case 1:  //rgb565
1076         LcdMskReg(inf, SWAP_CTRL, m_W0_YRGB_8_SWAP | m_W0_YRGB_16_SWAP | m_W0_YRGB_R_SHIFT_SWAP | m_W0_565_RB_SWAP | m_W0_YRGB_M8_SWAP | m_W0_CBR_8_SWAP,
1077             v_W0_YRGB_8_SWAP(0) | v_W0_YRGB_16_SWAP(0) | v_W0_YRGB_R_SHIFT_SWAP(0) | v_W0_565_RB_SWAP(1) | v_W0_YRGB_M8_SWAP(0) | v_W0_CBR_8_SWAP(0));
1078         break;
1079     case 4:   //yuv4201
1080         LcdMskReg(inf, SWAP_CTRL, m_W0_YRGB_8_SWAP | m_W0_YRGB_16_SWAP | m_W0_YRGB_R_SHIFT_SWAP | m_W0_565_RB_SWAP | m_W0_YRGB_M8_SWAP | m_W0_CBR_8_SWAP,
1081             v_W0_YRGB_8_SWAP(0) | v_W0_YRGB_16_SWAP(0) | v_W0_YRGB_R_SHIFT_SWAP(0) | v_W0_565_RB_SWAP(0) |
1082             v_W0_YRGB_M8_SWAP((var->rotate==0)) | v_W0_CBR_8_SWAP(0));
1083         break;
1084     default:
1085         LcdMskReg(inf, SWAP_CTRL, m_W0_YRGB_8_SWAP | m_W0_YRGB_16_SWAP | m_W0_YRGB_R_SHIFT_SWAP | m_W0_565_RB_SWAP | m_W0_YRGB_M8_SWAP | m_W0_CBR_8_SWAP,
1086             v_W0_YRGB_8_SWAP(0) | v_W0_YRGB_16_SWAP(0) | v_W0_YRGB_R_SHIFT_SWAP(0) | v_W0_565_RB_SWAP(0) | v_W0_YRGB_M8_SWAP(0) | v_W0_CBR_8_SWAP(0) );
1087     }
1088
1089     LcdWrReg(inf, REG_CFG_DONE, 0x01);
1090
1091     return 0;
1092 }
1093
1094 static int win0fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
1095 {
1096     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1097    // struct fb_var_screeninfo *var0 = &info->var;
1098     struct fb_fix_screeninfo *fix0 = &info->fix;
1099     struct win0_par *par = info->par;
1100     u32 y_addr=0, uv_addr=0;
1101
1102     fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1103
1104         CHK_SUSPEND(inf);
1105
1106     y_addr = fix0->smem_start +  par->y_offset;//y_offset;
1107     uv_addr = fix0->mmio_start + par->uv_offset ;//uv_offset;
1108
1109     LcdWrReg(inf, WIN0_YRGB_MST, y_addr);
1110     LcdWrReg(inf, WIN0_CBR_MST, uv_addr);
1111     LcdWrReg(inf, REG_CFG_DONE, 0x01);
1112
1113      // enable win0 after the win0 addr is seted
1114     par->par_seted = 1;
1115         LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE((1==par->addr_seted)?(1):(0)));
1116         mcu_refresh(inf);
1117
1118     return 0;
1119 }
1120
1121 int win0fb_open(struct fb_info *info, int user)
1122 {
1123     struct win0_par *par = info->par;
1124
1125     fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1126
1127     par->par_seted = 0;
1128     par->addr_seted = 0;
1129
1130     if(par->refcount) {
1131         printk(">>>>>> win0fb has opened! \n");
1132         return -EACCES;
1133     } else {
1134         par->refcount++;
1135         return 0;
1136     }
1137 }
1138
1139 int win0fb_release(struct fb_info *info, int user)
1140 {
1141     struct win0_par *par = info->par;
1142         struct fb_var_screeninfo *var0 = &info->var;
1143
1144     fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1145
1146     if(par->refcount) {
1147         par->refcount--;
1148
1149         win0fb_blank(FB_BLANK_POWERDOWN, info);
1150         // wait for lcdc stop access memory
1151         msleep(50);
1152
1153         // unmap memory
1154         if (info->screen_base) {
1155             printk(">>>>>> win0fb unmap memory(%d)! \n", info->fix.smem_len);
1156             dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len),info->screen_base, info->fix.smem_start);
1157             info->screen_base = 0;
1158             info->fix.smem_start = 0;
1159             info->fix.smem_len = 0;
1160         }
1161
1162                 // clean the var param
1163                 memset(var0, 0, sizeof(struct fb_var_screeninfo));
1164     }
1165
1166     return 0;
1167 }
1168
1169 static int win0fb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
1170 {
1171     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1172     struct win0_par *par = info->par;
1173     void __user *argp = (void __user *)arg;
1174
1175         fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1176     fbprintk("win0fb_ioctl cmd = %8x, arg = %8x \n", (u32)cmd, (u32)arg);
1177
1178         CHK_SUSPEND(inf);
1179
1180     switch(cmd)
1181     {
1182     case FB1_IOCTL_GET_PANEL_SIZE:    //get panel size
1183         {
1184             u32 panel_size[2];
1185              if(inf->win0fb->var.rotate == 270) {
1186                 panel_size[0] = inf->cur_screen->y_res;
1187                 panel_size[1] = inf->cur_screen->x_res;
1188             } else {
1189                 panel_size[0] = inf->cur_screen->x_res;
1190                 panel_size[1] = inf->cur_screen->y_res;
1191             }
1192
1193             if(copy_to_user(argp, panel_size, 8))  return -EFAULT;
1194         }
1195         break;
1196
1197     case FB1_IOCTL_SET_YUV_ADDR:    //set y&uv address to register direct
1198         {
1199             u32 yuv_phy[2];
1200             if (copy_from_user(yuv_phy, argp, 8))
1201                             return -EFAULT;
1202
1203             yuv_phy[0] += par->y_offset;
1204             yuv_phy[1] += par->uv_offset;
1205
1206             LcdWrReg(inf, WIN0_YRGB_MST, yuv_phy[0]);
1207             LcdWrReg(inf, WIN0_CBR_MST, yuv_phy[1]);
1208             LcdWrReg(inf, REG_CFG_DONE, 0x01);
1209             // enable win0 after the win0 par is seted
1210             par->addr_seted = 1;
1211             if(par->par_seted) {
1212                 LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(1));
1213                 mcu_refresh(inf);
1214             }
1215         }
1216         break;
1217
1218     case FB1_IOCTL_SET_ROTATE:    //change MCU panel scan direction
1219         fbprintk(">>>>>> change lcdc direction(%d) \n", (int)arg);
1220         return -1;
1221         break;
1222     default:
1223         break;
1224     }
1225     return 0;
1226 }
1227
1228 static struct fb_ops win0fb_ops = {
1229         .owner          = THIS_MODULE,
1230         .fb_open    = win0fb_open,
1231         .fb_release = win0fb_release,
1232         .fb_check_var   = win0fb_check_var,
1233         .fb_set_par     = win0fb_set_par,
1234         .fb_blank       = win0fb_blank,
1235     .fb_pan_display = win0fb_pan_display,
1236     .fb_ioctl = win0fb_ioctl,
1237         .fb_setcolreg   = fb_setcolreg,
1238         .fb_fillrect    = cfb_fillrect,
1239         .fb_copyarea    = cfb_copyarea,
1240         .fb_imageblit   = cfb_imageblit,
1241 };
1242
1243 static int win1fb_blank(int blank_mode, struct fb_info *info)
1244 {
1245     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1246
1247     fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1248
1249         CHK_SUSPEND(inf);
1250
1251         switch(blank_mode)
1252     {
1253     case FB_BLANK_UNBLANK:
1254         LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(1));
1255         break;
1256     default:
1257         LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(0));
1258         break;
1259     }
1260     LcdWrReg(inf, REG_CFG_DONE, 0x01);
1261
1262         mcu_refresh(inf);
1263     return 0;
1264 }
1265
1266 static int win1fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1267 {
1268     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1269     struct rk29fb_screen *screen = inf->cur_screen;
1270     u16 xpos = (var->nonstd>>8) & 0xfff;
1271     u16 ypos = (var->nonstd>>20) & 0xfff;
1272     u16 xlcd = screen->x_res;
1273     u16 ylcd = screen->y_res;
1274     u8 trspmode = (var->grayscale>>8) & 0xff;
1275     u8 trspval = (var->grayscale) & 0xff;
1276
1277     //fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1278
1279         CHK_SUSPEND(inf);
1280
1281     if( 0==var->xres_virtual || 0==var->yres_virtual ||
1282         0==var->xres || 0==var->yres || var->xres<16 ||
1283         ((16!=var->bits_per_pixel)&&(32!=var->bits_per_pixel)) )
1284     {
1285         printk(">>>>>> win1fb_check_var fail 1!!! \n");
1286         printk(">>>>>> 0==%d || 0==%d ", var->xres_virtual,var->yres_virtual);
1287         printk("0==%d || 0==%d || %d<16 || ", var->xres,var->yres,var->xres<16);
1288         printk("%d>5 || %d>16 \n", trspmode,trspval);
1289         printk("bits_per_pixel=%d \n", var->bits_per_pixel);
1290         return -EINVAL;
1291     }
1292
1293     if( (var->xoffset+var->xres)>var->xres_virtual ||
1294         (var->yoffset+var->yres)>var->yres_virtual )
1295     {
1296         printk(">>>>>> win1fb_check_var fail 2!!! \n");
1297         printk(">>>>>> (%d+%d)>%d || ", var->xoffset,var->xres,var->xres_virtual);
1298         printk("(%d+%d)>%d || ", var->yoffset,var->yres,var->yres_virtual);
1299         printk("(%d+%d)>%d || (%d+%d)>%d \n", xpos,var->xres,xlcd,ypos,var->yres,ylcd);
1300         return -EINVAL;
1301     }
1302
1303     switch(var->bits_per_pixel)
1304     {
1305     case 16:    // rgb565
1306         var->xres_virtual = (var->xres_virtual + 0x1) & (~0x1);
1307         var->xres = (var->xres + 0x1) & (~0x1);
1308         var->xoffset = (var->xoffset) & (~0x1);
1309         break;
1310     default:    // rgb888
1311         var->bits_per_pixel = 32;
1312         break;
1313     }
1314
1315     return 0;
1316 }
1317
1318 static int win1fb_set_par(struct fb_info *info)
1319 {
1320     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1321     struct fb_var_screeninfo *var = &info->var;
1322     struct fb_fix_screeninfo *fix = &info->fix;
1323     struct rk29fb_screen *screen = inf->cur_screen;
1324
1325     u8 format = 0;
1326     u32 offset=0, addr=0, map_size=0, smem_len=0;
1327
1328     u16 xres_virtual = var->xres_virtual;      //virtual screen size
1329     //u16 yres_virtual = var->yres_virtual;
1330
1331     u16 xpos_virtual = var->xoffset;           //visiable offset in virtual screen
1332     u16 ypos_virtual = var->yoffset;
1333
1334     u16 xpos = 0;                 //visiable offset in panel
1335     u16 ypos = 0;
1336     u16 xsize = screen->x_res;    //visiable size in panel
1337     u16 ysize = screen->y_res;
1338     u8 trspmode = TRSP_CLOSE;
1339     u8 trspval = 0;
1340
1341     //fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1342
1343         CHK_SUSPEND(inf);
1344
1345     switch(var->bits_per_pixel)
1346     {
1347     case 16:    // rgb565
1348         format = 1;
1349         fix->line_length = 2 * xres_virtual;
1350         offset = (ypos_virtual*xres_virtual + xpos_virtual)*2;
1351         break;
1352     case 32:    // rgb888
1353     default:
1354         format = 0;
1355         fix->line_length = 4 * xres_virtual;
1356         offset = (ypos_virtual*xres_virtual + xpos_virtual)*4;
1357         break;
1358     }
1359
1360     smem_len = fix->line_length * var->yres_virtual;   //cursor buf also alloc here
1361     map_size = PAGE_ALIGN(smem_len);
1362
1363     if (smem_len > fix->smem_len)     // buffer need realloc
1364     {
1365         printk("%s win1 buf \n",__FUNCTION__);
1366        #if 0
1367         fbprintk(">>>>>> win1 buffer size is change(%d->%d)! remap memory!\n",fix->smem_len, smem_len);
1368         fbprintk(">>>>>> smem_len %d = %d * %d \n", smem_len, fix->line_length, var->yres_virtual);
1369         fbprintk(">>>>>> map_size = %d\n", map_size);
1370         LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(0));
1371         LcdWrReg(inf, REG_CFG_DONE, 0x01);
1372         msleep(50);
1373         if (info->screen_base) {
1374             printk(">>>>>> win1fb unmap memory(%d)! \n", info->fix.smem_len);
1375                 dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len), info->screen_base, info->fix.smem_start);
1376                 info->screen_base = 0;
1377                 fix->smem_start = 0;
1378                 fix->smem_len = 0;
1379         }
1380
1381         info->screen_base = dma_alloc_writecombine(NULL, map_size, &map_dma, GFP_KERNEL);
1382         if(!info->screen_base) {
1383             printk(">>>>>> win1fb dma_alloc_writecombine fail!\n");
1384             return -ENOMEM;
1385         }
1386         memset(info->screen_base, 0, map_size);
1387         fix->smem_start = map_dma;
1388         fix->smem_len = smem_len;
1389
1390         fbprintk(">>>>>> alloc succ, mem=%08x, len=%d!\n", (u32)fix->smem_start, fix->smem_len);
1391         #endif
1392     }
1393
1394
1395     addr = fix->smem_start + offset;
1396
1397 #if ANDROID_USE_THREE_BUFS
1398     if(0==new_frame_seted) {
1399         wq_condition = 0;
1400         wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
1401     }
1402     new_frame_seted = 0;
1403 #endif
1404
1405     LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE|m_W1_FORMAT, v_W1_ENABLE(1)|v_W1_FORMAT(format));
1406
1407     xpos += (screen->left_margin + screen->hsync_len);
1408     ypos += (screen->upper_margin + screen->vsync_len);
1409
1410     LcdWrReg(inf, WIN1_YRGB_MST, addr);
1411
1412     LcdMskReg(inf, WIN1_DSP_ST, m_BIT11LO|m_BIT11HI, v_BIT11LO(xpos) | v_BIT11HI(ypos));
1413     LcdMskReg(inf, WIN1_DSP_INFO, m_BIT11LO|m_BIT11HI, v_BIT11LO(xsize) | v_BIT11HI(ysize));
1414
1415     LcdMskReg(inf, WIN1_VIR, m_WORDLO | m_WORDHI , v_WORDLO(xres_virtual) | v_WORDHI(var->yres_virtual));
1416
1417     LcdMskReg(inf, BLEND_CTRL, m_W1_BLEND_EN |  m_W1_BLEND_FACTOR,
1418         v_W1_BLEND_EN((TRSP_FMREG==trspmode) || (TRSP_MASK==trspmode)) | v_W1_BLEND_FACTOR(trspval));
1419
1420      // enable win1 color key and set the color to black(rgb=0)
1421     LcdMskReg(inf, WIN1_COLOR_KEY_CTRL, m_COLORKEY_EN | m_KEYCOLOR, v_COLORKEY_EN(1) | v_KEYCOLOR(0));
1422
1423     if(1==format) //rgb565
1424     {
1425         LcdMskReg(inf, SWAP_CTRL, m_W1_8_SWAP | m_W1_16_SWAP | m_W1_R_SHIFT_SWAP | m_W1_565_RB_SWAP,
1426             v_W1_8_SWAP(0) | v_W1_16_SWAP(0) | v_W1_R_SHIFT_SWAP(0) | v_W1_565_RB_SWAP(0) );
1427     }
1428     else
1429     {
1430      LcdMskReg(inf, SWAP_CTRL, m_W1_8_SWAP | m_W1_16_SWAP | m_W1_R_SHIFT_SWAP | m_W1_565_RB_SWAP,
1431             v_W1_8_SWAP(1) | v_W1_16_SWAP(1) | v_W1_R_SHIFT_SWAP(1) | v_W1_565_RB_SWAP(0) );
1432
1433      LcdMskReg(inf, DSP_CTRL0, m_W1_TRANSP_FROM, v_W1_TRANSP_FROM(TRSP_FMRAM==trspmode) );
1434     }
1435
1436         LcdWrReg(inf, REG_CFG_DONE, 0x01);
1437
1438     return 0;
1439 }
1440
1441 static int win1fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
1442 {
1443     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1444     struct fb_var_screeninfo *var1 = &info->var;
1445     struct fb_fix_screeninfo *fix1 = &info->fix;
1446
1447     u32 offset = 0, addr = 0;
1448
1449         //fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1450
1451         CHK_SUSPEND(inf);
1452
1453     switch(var1->bits_per_pixel)
1454     {
1455     case 16:    // rgb565
1456         var->xoffset = (var->xoffset) & (~0x1);
1457         offset = (var->yoffset*var1->xres_virtual + var->xoffset)*2;
1458         break;
1459     case 32:    // rgb888
1460         offset = (var->yoffset*var1->xres_virtual + var->xoffset)*4;
1461         break;
1462     default:
1463         return -EINVAL;
1464     }
1465
1466     addr = fix1->smem_start + offset;
1467
1468     //fbprintk("info->screen_base = %8x ; fix1->smem_len = %d , addr = %8x\n",(u32)info->screen_base, fix1->smem_len, addr);
1469
1470     LcdWrReg(inf, WIN1_YRGB_MST, addr);
1471     LcdWrReg(inf, REG_CFG_DONE, 0x01);
1472
1473         mcu_refresh(inf);
1474
1475 #if !ANDROID_USE_THREE_BUFS
1476     // flush end when wq_condition=1 in mcu panel, but not in rgb panel
1477     if(SCREEN_MCU == inf->cur_screen->type) {
1478         wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
1479         wq_condition = 0;
1480     } else {
1481         wq_condition = 0;
1482         wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
1483     }
1484 #endif
1485
1486     return 0;
1487 }
1488
1489
1490 static int win1fb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
1491 {
1492     struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1493     struct rk29fb_info *mach_info = info->device->platform_data;
1494     unsigned display_on;
1495     int display_on_pol;
1496
1497         fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1498
1499         CHK_SUSPEND(inf);
1500
1501     switch(cmd)
1502     {
1503     case FB0_IOCTL_STOP_TIMER_FLUSH:    //stop timer flush mcu panel after android is runing
1504         if(1==arg)
1505         {
1506             inf->mcu_usetimer = 0;
1507         }
1508         break;
1509
1510     case FB0_IOCTL_SET_PANEL:
1511         if(arg>7)   return -1;
1512
1513         /* Black out, because some display device need clock to standby */
1514         //LcdMskReg(inf, DSP_CTRL_REG1, m_BLACK_OUT, v_BLACK_OUT(1));
1515         LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(0));
1516         LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(0));
1517         LcdMskReg(inf, DSP_CTRL1, m_BLACK_MODE,  v_BLACK_MODE(1));
1518         LcdWrReg(inf, REG_CFG_DONE, 0x01);
1519         if(inf->cur_screen)
1520         {
1521             if(inf->cur_screen->standby)    inf->cur_screen->standby(1);
1522             // operate the display_on pin to power down the lcd
1523             if(SCREEN_RGB==inf->cur_screen->type || SCREEN_MCU==inf->cur_screen->type)
1524             {
1525                 if(mach_info && mach_info->disp_on_pin)
1526                 {
1527                     display_on = mach_info->disp_on_pin;
1528                     display_on_pol = mach_info->disp_on_value;
1529                     gpio_direction_output(display_on, 0);
1530                         gpio_set_value(display_on, !display_on_pol);
1531                 }
1532             }
1533         }
1534
1535         /* Load the new device's param */
1536         switch(arg)
1537         {
1538         case 0: inf->cur_screen = &inf->lcd_info;   break;  //lcd
1539         case 1: inf->cur_screen = &inf->tv_info[0]; break;  //tv ntsc cvbs
1540         case 2: inf->cur_screen = &inf->tv_info[1]; break;  //tv pal cvbs
1541         case 3: inf->cur_screen = &inf->tv_info[2]; break;  //tv 480 ypbpr
1542         case 4: inf->cur_screen = &inf->tv_info[3]; break;  //tv 576 ypbpr
1543         case 5: inf->cur_screen = &inf->tv_info[4]; break;  //tv 720 ypbpr
1544         case 6: inf->cur_screen = &inf->hdmi_info[0];  break;  //hdmi 576
1545         case 7: inf->cur_screen = &inf->hdmi_info[1];  break;  //hdmi 720
1546         default: break;
1547         }
1548         load_screen(info, 0);
1549                 mcu_refresh(inf);
1550         break;
1551     default:
1552         break;
1553     }
1554     return 0;
1555 }
1556
1557
1558 static struct fb_ops win1fb_ops = {
1559         .owner          = THIS_MODULE,
1560         .fb_check_var   = win1fb_check_var,
1561         .fb_set_par = win1fb_set_par,
1562         .fb_blank   = win1fb_blank,
1563         .fb_pan_display = win1fb_pan_display,
1564     .fb_ioctl = win1fb_ioctl,
1565         .fb_setcolreg   = fb_setcolreg,
1566         .fb_fillrect    = cfb_fillrect,
1567         .fb_copyarea    = cfb_copyarea,
1568         .fb_imageblit   = cfb_imageblit,
1569         //.fb_cursor      = rk29_set_cursor,
1570 };
1571
1572
1573 static irqreturn_t rk29fb_irq(int irq, void *dev_id)
1574 {
1575         struct platform_device *pdev = (struct platform_device*)dev_id;
1576     struct rk29fb_inf *inf = platform_get_drvdata(pdev);
1577     if(!inf)
1578         return IRQ_HANDLED;
1579
1580         //fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1581
1582     LcdMskReg(inf, INT_STATUS, m_FRM_STARTCLEAR, v_FRM_STARTCLEAR(1));
1583
1584         if(SCREEN_MCU == inf->cur_screen->type)
1585         {
1586         inf->mcu_isrcnt = !inf->mcu_isrcnt;
1587         if(inf->mcu_isrcnt)
1588             return IRQ_HANDLED;
1589
1590         if(IsMcuUseFmk())
1591         {
1592             if(LcdReadBit(inf, MCU_TIMING_CTRL, m_MCU_HOLD_STATUS) && (inf->mcu_fmksync == 0))
1593             {
1594                 inf->mcu_fmksync = 1;
1595                  if(inf->cur_screen->refresh)
1596                    inf->cur_screen->refresh(REFRESH_END);
1597                 inf->mcu_fmksync = 0;
1598             }
1599             else
1600             {
1601                 return IRQ_HANDLED;
1602             }
1603         }
1604         else
1605         {
1606             if(inf->mcu_needflush) {
1607                 if(inf->cur_screen->refresh)
1608                     inf->cur_screen->refresh(REFRESH_PRE);
1609                 inf->mcu_needflush = 0;
1610                 inf->mcu_isrcnt = 0;
1611                 LcdSetRegBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST);
1612             } else {
1613                 if(inf->cur_screen->refresh)
1614                     inf->cur_screen->refresh(REFRESH_END);
1615             }
1616         }
1617         }
1618
1619 #if ANDROID_USE_THREE_BUFS
1620     new_frame_seted = 1;
1621 #endif
1622
1623         wq_condition = 1;
1624         wake_up_interruptible(&wq);
1625
1626         return IRQ_HANDLED;
1627 }
1628
1629 #ifdef CONFIG_HAS_EARLYSUSPEND
1630
1631 struct suspend_info {
1632         struct early_suspend early_suspend;
1633         struct rk29fb_inf *inf;
1634 };
1635
1636 void suspend(struct early_suspend *h)
1637 {
1638         struct suspend_info *info = container_of(h, struct suspend_info,
1639                                                 early_suspend);
1640
1641     struct rk29fb_inf *inf = info->inf;
1642
1643     fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1644
1645     if(!inf) {
1646         printk("inf==0, rk29fb_suspend fail! \n");
1647         return;
1648     }
1649
1650     set_lcd_pin(g_pdev, 0);
1651
1652         if(inf->cur_screen->standby)
1653         {
1654                 fbprintk(">>>>>> power down the screen! \n");
1655                 inf->cur_screen->standby(1);
1656         }
1657
1658     LcdMskReg(inf, DSP_CTRL1, m_BLANK_MODE , v_BLANK_MODE(1));
1659     LcdMskReg(inf, SYS_CONFIG, m_STANDBY, v_STANDBY(1));
1660         LcdWrReg(inf, REG_CFG_DONE, 0x01);
1661
1662         if(!inf->in_suspend)
1663         {
1664                 fbprintk(">>>>>> diable the lcdc clk! \n");
1665                 msleep(100);
1666         if (inf->dclk){
1667             clk_disable(inf->dclk);
1668         }
1669         if(inf->clk){
1670             clk_disable(inf->clk);
1671         }
1672
1673                 inf->in_suspend = 1;
1674         }
1675
1676 }
1677
1678 void resume(struct early_suspend *h)
1679 {
1680         struct suspend_info *info = container_of(h, struct suspend_info,
1681                                         early_suspend);
1682
1683     struct rk29fb_inf *inf = info->inf;
1684
1685     fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1686     if(!inf) {
1687         printk("inf==0, rk29fb_resume fail! \n");
1688         return ;
1689     }
1690
1691         if(inf->in_suspend)
1692         {
1693             inf->in_suspend = 0;
1694         fbprintk(">>>>>> enable the lcdc clk! \n");
1695         if (inf->dclk){
1696             clk_enable(inf->dclk);
1697         }
1698         if(inf->clk){
1699             clk_enable(inf->clk);
1700         }
1701         msleep(100);
1702         }
1703     LcdMskReg(inf, DSP_CTRL1, m_BLANK_MODE , v_BLANK_MODE(0));
1704     LcdMskReg(inf, SYS_CONFIG, m_STANDBY, v_STANDBY(0));
1705     LcdWrReg(inf, REG_CFG_DONE, 0x01);
1706
1707         if(inf->cur_screen->standby)
1708         {
1709                 fbprintk(">>>>>> power on the screen! \n");
1710                 inf->cur_screen->standby(0);
1711         }
1712     msleep(100);
1713     set_lcd_pin(g_pdev, 1);
1714         memcpy((u8*)inf->preg, (u8*)&inf->regbak, 0xa4);  //resume reg
1715 }
1716
1717 struct suspend_info suspend_info = {
1718         .early_suspend.suspend = suspend,
1719         .early_suspend.resume = resume,
1720         .early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB,
1721 };
1722 #endif
1723
1724 static int __init rk29fb_probe (struct platform_device *pdev)
1725 {
1726     struct rk29fb_inf *inf = NULL;
1727     struct resource *res = NULL;
1728     struct resource *mem = NULL;
1729     struct rk29fb_info *mach_info = NULL;
1730     struct rk29fb_screen *screen = NULL;
1731         int irq = 0;
1732     int ret = 0;
1733
1734     fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1735
1736     *(volatile u32 *)(RK29_GRF_BASE+0xac) = ((*(volatile u32 *)(RK29_GRF_BASE+0xac)) & ~0x3FF) | 0x246;
1737
1738     /* Malloc rk29fb_inf and set it to pdev for drvdata */
1739     fbprintk(">> Malloc rk29fb_inf and set it to pdev for drvdata \n");
1740     inf = kmalloc(sizeof(struct rk29fb_inf), GFP_KERNEL);
1741     if(!inf)
1742     {
1743         dev_err(&pdev->dev, ">> inf kmalloc fail!");
1744         ret = -ENOMEM;
1745                 goto release_drvdata;
1746     }
1747     memset(inf, 0, sizeof(struct rk29fb_inf));
1748         platform_set_drvdata(pdev, inf);
1749
1750     mach_info = pdev->dev.platform_data;
1751     /* Fill screen info and set current screen */
1752     fbprintk(">> Fill screen info and set current screen \n");
1753     set_lcd_info(&inf->lcd_info, mach_info->lcd_info);
1754     set_tv_info(&inf->tv_info[0]);
1755     set_hdmi_info(&inf->hdmi_info[0]);
1756     inf->cur_screen = &inf->lcd_info;
1757     screen = inf->cur_screen;
1758     if(SCREEN_NULL==screen->type)
1759     {
1760         dev_err(&pdev->dev, ">> Please select a display device! \n");
1761         ret = -EINVAL;
1762                 goto release_drvdata;
1763     }
1764
1765     /* get virtual basic address of lcdc register */
1766     fbprintk(">> get virtual basic address of lcdc register \n");
1767     res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lcdc reg");
1768     if (res == NULL)
1769     {
1770         dev_err(&pdev->dev, "failed to get memory registers\n");
1771         ret = -ENOENT;
1772                 goto release_drvdata;
1773     }
1774     inf->reg_phy_base = res->start;
1775     inf->len = (res->end - res->start) + 1;
1776     mem = request_mem_region(inf->reg_phy_base, inf->len, pdev->name);
1777     if (mem == NULL)
1778     {
1779         dev_err(&pdev->dev, "failed to get memory region\n");
1780         ret = -ENOENT;
1781                 goto release_drvdata;
1782     }
1783     fbprintk("inf->reg_phy_base = 0x%08x, inf->len = %d \n", inf->reg_phy_base, inf->len);
1784     inf->reg_vir_base = ioremap(inf->reg_phy_base, inf->len);
1785     if (inf->reg_vir_base == NULL)
1786     {
1787         dev_err(&pdev->dev, "ioremap() of registers failed\n");
1788         ret = -ENXIO;
1789                 goto release_drvdata;
1790     }
1791     inf->preg = (LCDC_REG*)inf->reg_vir_base;
1792
1793     /* Prepare win1 info */
1794     fbprintk(">> Prepare win1 info \n");
1795         inf->win1fb = framebuffer_alloc(sizeof(struct win1_par), &pdev->dev);
1796     if(!inf->win1fb)
1797     {
1798         dev_err(&pdev->dev, ">> win1fb framebuffer_alloc fail!");
1799                 inf->win1fb = NULL;
1800         ret = -ENOMEM;
1801                 goto release_win1fb;
1802     }
1803
1804     strcpy(inf->win1fb->fix.id, "win1fb");
1805     inf->win1fb->fix.type        = FB_TYPE_PACKED_PIXELS;
1806     inf->win1fb->fix.type_aux    = 0;
1807     inf->win1fb->fix.xpanstep    = 1;
1808     inf->win1fb->fix.ypanstep    = 1;
1809     inf->win1fb->fix.ywrapstep   = 0;
1810     inf->win1fb->fix.accel       = FB_ACCEL_NONE;
1811     inf->win1fb->fix.visual      = FB_VISUAL_TRUECOLOR;
1812     inf->win1fb->fix.smem_len    = 0;
1813     inf->win1fb->fix.line_length = 0;
1814     inf->win1fb->fix.smem_start  = 0;
1815
1816     inf->win1fb->var.xres = screen->x_res;
1817     inf->win1fb->var.yres = screen->y_res;
1818     inf->win1fb->var.bits_per_pixel = 16;
1819     inf->win1fb->var.xres_virtual = screen->x_res;
1820     inf->win1fb->var.yres_virtual = screen->y_res;
1821     inf->win1fb->var.width = screen->width;
1822     inf->win1fb->var.height = screen->height;
1823     inf->win1fb->var.pixclock = screen->pixclock;
1824     inf->win1fb->var.left_margin = screen->left_margin;
1825     inf->win1fb->var.right_margin = screen->right_margin;
1826     inf->win1fb->var.upper_margin = screen->upper_margin;
1827     inf->win1fb->var.lower_margin = screen->lower_margin;
1828     inf->win1fb->var.vsync_len = screen->vsync_len;
1829     inf->win1fb->var.hsync_len = screen->hsync_len;
1830     inf->win1fb->var.red    = def_rgb_16.red;
1831     inf->win1fb->var.green  = def_rgb_16.green;
1832     inf->win1fb->var.blue   = def_rgb_16.blue;
1833     inf->win1fb->var.transp = def_rgb_16.transp;
1834
1835     inf->win1fb->var.nonstd      = 0;  //win1 format & ypos & xpos (ypos<<20 + xpos<<8 + format)
1836     inf->win1fb->var.grayscale   = 0;  //win1 transprent mode & value(mode<<8 + value)
1837     inf->win1fb->var.activate    = FB_ACTIVATE_NOW;
1838     inf->win1fb->var.accel_flags = 0;
1839     inf->win1fb->var.vmode       = FB_VMODE_NONINTERLACED;
1840
1841     inf->win1fb->fbops           = &win1fb_ops;
1842     inf->win1fb->flags           = FBINFO_FLAG_DEFAULT;
1843     inf->win1fb->pseudo_palette  = ((struct win1_par*)inf->win1fb->par)->pseudo_pal;
1844     inf->win1fb->screen_base     = 0;
1845
1846     memset(inf->win1fb->par, 0, sizeof(struct win1_par));
1847         ret = fb_alloc_cmap(&inf->win1fb->cmap, 256, 0);
1848         if (ret < 0)
1849                 goto release_cmap;
1850
1851     /* alloc win1 buf */
1852     res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "win1 buf");
1853     if (res == NULL)
1854     {
1855         dev_err(&pdev->dev, "failed to get win1 memory \n");
1856         ret = -ENOENT;
1857         goto release_win1fb;
1858     }
1859     inf->win1fb->fix.smem_start = res->start;
1860     inf->win1fb->fix.smem_len = res->end - res->start;
1861     inf->win1fb->screen_base = ioremap(res->start, inf->win1fb->fix.smem_len);
1862     memset(inf->win1fb->screen_base, 0, inf->win1fb->fix.smem_len);
1863
1864     /* Prepare win0 info */
1865     fbprintk(">> Prepare win0 info \n");
1866     inf->win0fb = framebuffer_alloc(sizeof(struct win0_par), &pdev->dev);
1867     if(!inf->win0fb)
1868     {
1869         dev_err(&pdev->dev, ">> win0fb framebuffer_alloc fail!");
1870                 inf->win0fb = NULL;
1871                 ret = -ENOMEM;
1872                 goto release_win0fb;
1873     }
1874
1875     strcpy(inf->win0fb->fix.id, "win0fb");
1876         inf->win0fb->fix.type         = FB_TYPE_PACKED_PIXELS;
1877         inf->win0fb->fix.type_aux    = 0;
1878         inf->win0fb->fix.xpanstep    = 1;
1879         inf->win0fb->fix.ypanstep    = 1;
1880         inf->win0fb->fix.ywrapstep   = 0;
1881         inf->win0fb->fix.accel       = FB_ACCEL_NONE;
1882     inf->win0fb->fix.visual      = FB_VISUAL_TRUECOLOR;
1883     inf->win0fb->fix.smem_len    = 0;
1884     inf->win0fb->fix.line_length = 0;
1885     inf->win0fb->fix.smem_start  = 0;
1886
1887     inf->win0fb->var.xres = screen->x_res;
1888     inf->win0fb->var.yres = screen->y_res;
1889     inf->win0fb->var.bits_per_pixel = 16;
1890     inf->win0fb->var.xres_virtual = screen->x_res;
1891     inf->win0fb->var.yres_virtual = screen->y_res;
1892     inf->win0fb->var.width = screen->width;
1893     inf->win0fb->var.height = screen->height;
1894     inf->win0fb->var.pixclock = screen->pixclock;
1895     inf->win0fb->var.left_margin = screen->left_margin;
1896     inf->win0fb->var.right_margin = screen->right_margin;
1897     inf->win0fb->var.upper_margin = screen->upper_margin;
1898     inf->win0fb->var.lower_margin = screen->lower_margin;
1899     inf->win0fb->var.vsync_len = screen->vsync_len;
1900     inf->win0fb->var.hsync_len = screen->hsync_len;
1901     inf->win0fb->var.red    = def_rgb_16.red;
1902     inf->win0fb->var.green  = def_rgb_16.green;
1903     inf->win0fb->var.blue   = def_rgb_16.blue;
1904     inf->win0fb->var.transp = def_rgb_16.transp;
1905
1906     inf->win0fb->var.nonstd      = 0;  //win0 format & ypos & xpos (ypos<<20 + xpos<<8 + format)
1907     inf->win0fb->var.grayscale   = ((inf->win0fb->var.yres<<20)&0xfff00000) + ((inf->win0fb->var.xres<<8)&0xfff00);//win0 xsize & ysize
1908     inf->win0fb->var.activate    = FB_ACTIVATE_NOW;
1909     inf->win0fb->var.accel_flags = 0;
1910     inf->win0fb->var.vmode       = FB_VMODE_NONINTERLACED;
1911
1912     inf->win0fb->fbops           = &win0fb_ops;
1913         inf->win0fb->flags                    = FBINFO_FLAG_DEFAULT;
1914         inf->win0fb->pseudo_palette  = ((struct win0_par*)inf->win0fb->par)->pseudo_pal;
1915         inf->win0fb->screen_base     = 0;
1916
1917     memset(inf->win0fb->par, 0, sizeof(struct win0_par));
1918
1919         /* Init all lcdc and lcd before register_framebuffer. */
1920         /* because after register_framebuffer, the win1fb_check_par and winfb_set_par execute immediately */
1921         fbprintk(">> Init all lcdc and lcd before register_framebuffer \n");
1922     init_lcdc(inf->win1fb);
1923
1924   #ifdef CONFIG_CPU_FREQ
1925    // inf->freq_transition.notifier_call = rk29fb_freq_transition;
1926    // cpufreq_register_notifier(&inf->freq_transition, CPUFREQ_TRANSITION_NOTIFIER);
1927   #endif
1928         fbprintk("got clock\n");
1929
1930         if(mach_info)
1931     {
1932         struct rk29_fb_setting_info fb_setting;
1933         if( OUT_P888==inf->lcd_info.face ||
1934             OUT_P888==inf->tv_info[0].face ||
1935             OUT_P888==inf->hdmi_info[0].face )     // set lcdc iomux
1936         {
1937             fb_setting.data_num = 24;
1938         }
1939         else if(OUT_P666 == inf->lcd_info.face )
1940         {
1941             fb_setting.data_num = 18;
1942         }
1943         else
1944         {
1945             fb_setting.data_num = 16;
1946         }
1947         fb_setting.den_en = 1;
1948         fb_setting.vsync_en = 1;
1949         fb_setting.disp_on_en = 1;
1950         fb_setting.standby_en = 1;
1951         if( inf->lcd_info.mcu_usefmk )
1952             fb_setting.mcu_fmk_en =1;
1953         mach_info->io_init(&fb_setting);
1954     }
1955
1956         set_lcd_pin(pdev, 1);
1957         mdelay(10);
1958         g_pdev = pdev;
1959         inf->mcu_usetimer = 1;
1960     inf->mcu_fmksync = 0;
1961         load_screen(inf->win1fb, 1);
1962
1963     /* Register framebuffer(win1fb & win0fb) */
1964     fbprintk(">> Register framebuffer(win1fb) \n");
1965     ret = register_framebuffer(inf->win1fb);
1966     if(ret<0)
1967     {
1968         printk(">> win1fb register_framebuffer fail!\n");
1969         ret = -EINVAL;
1970                 goto release_win0fb;
1971     }
1972     fbprintk(">> Register framebuffer(win0fb) \n");
1973
1974     ret = register_framebuffer(inf->win0fb);
1975     if(ret<0)
1976     {
1977         printk(">> win0fb register_framebuffer fail!\n");
1978         ret = -EINVAL;
1979                 goto unregister_win1fb;
1980     }
1981
1982 #ifdef CONFIG_HAS_EARLYSUSPEND
1983         suspend_info.inf = inf;
1984         register_early_suspend(&suspend_info.early_suspend);
1985 #endif
1986
1987     /* get and request irq */
1988     fbprintk(">> get and request irq \n");
1989     irq = platform_get_irq(pdev, 0);
1990     if (irq < 0) {
1991         dev_err(&pdev->dev, "no irq for device\n");
1992         ret = -ENOENT;
1993         goto unregister_win1fb;
1994     }
1995     ret = request_irq(irq, rk29fb_irq, IRQF_DISABLED, pdev->name, pdev);
1996     if (ret) {
1997         dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
1998         ret = -EBUSY;
1999         goto release_irq;
2000     }
2001
2002     if( inf->lcd_info.mcu_usefmk && (mach_info->mcu_fmk_pin != -1) )
2003     {
2004         ret = request_irq(gpio_to_irq(mach_info->mcu_fmk_pin), mcu_irqfmk, GPIOEdgelFalling, pdev->name, pdev);
2005         if (ret)
2006         {
2007             dev_err(&pdev->dev, "cannot get fmk irq %d - err %d\n", irq, ret);
2008             ret = -EBUSY;
2009             goto release_irq;
2010         }
2011     }
2012
2013     printk(" %s ok\n", __FUNCTION__);
2014     return ret;
2015
2016 release_irq:
2017         if(irq>=0)
2018         free_irq(irq, pdev);
2019 unregister_win1fb:
2020     unregister_framebuffer(inf->win1fb);
2021 release_win0fb:
2022         if(inf->win0fb)
2023                 framebuffer_release(inf->win0fb);
2024         inf->win0fb = NULL;
2025 release_cmap:
2026     if(&inf->win1fb->cmap)
2027         fb_dealloc_cmap(&inf->win1fb->cmap);
2028 release_win1fb:
2029         if(inf->win1fb)
2030                 framebuffer_release(inf->win1fb);
2031         inf->win1fb = NULL;
2032 release_drvdata:
2033         if(inf && inf->reg_vir_base)
2034         iounmap(inf->reg_vir_base);
2035         if(inf && mem)
2036         release_mem_region(inf->reg_phy_base, inf->len);
2037         if(inf)
2038         kfree(inf);
2039         platform_set_drvdata(pdev, NULL);
2040         return ret;
2041 }
2042
2043 static int rk29fb_remove(struct platform_device *pdev)
2044 {
2045     struct rk29fb_inf *inf = platform_get_drvdata(pdev);
2046     struct fb_info *info = NULL;
2047         //pm_message_t msg;
2048     struct rk29fb_info *mach_info = NULL;
2049     int irq = 0;
2050
2051         fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
2052
2053     if(!inf) {
2054         printk("inf==0, rk29_fb_remove fail! \n");
2055         return -EINVAL;
2056     }
2057
2058     irq = platform_get_irq(pdev, 0);
2059     if (irq >0)
2060     {
2061     free_irq(irq, pdev);
2062     }
2063
2064     mach_info = pdev->dev.platform_data;
2065     if(mach_info->mcu_fmk_pin)
2066     {
2067         free_irq(gpio_to_irq(mach_info->mcu_fmk_pin), pdev);
2068     }
2069
2070         set_lcd_pin(pdev, 0);
2071
2072     // blank the lcdc
2073     if(inf->win0fb)
2074         win0fb_blank(FB_BLANK_POWERDOWN, inf->win0fb);
2075     if(inf->win1fb)
2076         win1fb_blank(FB_BLANK_POWERDOWN, inf->win1fb);
2077
2078         // suspend the lcdc
2079         //rk29fb_suspend(pdev, msg);
2080     // unmap memory and release framebuffer
2081     if(inf->win0fb) {
2082         info = inf->win0fb;
2083         if (info->screen_base) {
2084                 //dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len),info->screen_base, info->fix.smem_start);
2085                 info->screen_base = 0;
2086                 info->fix.smem_start = 0;
2087                 info->fix.smem_len = 0;
2088         }
2089         unregister_framebuffer(inf->win0fb);
2090         framebuffer_release(inf->win0fb);
2091         inf->win0fb = NULL;
2092     }
2093     if(inf->win1fb) {
2094         info = inf->win1fb;
2095         if (info->screen_base) {
2096             //    dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len),info->screen_base, info->fix.smem_start);
2097                 info->screen_base = 0;
2098                 info->fix.smem_start = 0;
2099                 info->fix.smem_len = 0;
2100         }
2101         unregister_framebuffer(inf->win1fb);
2102         framebuffer_release(inf->win1fb);
2103         inf->win1fb = NULL;
2104     }
2105
2106   #ifdef CONFIG_CPU_FREQ
2107     cpufreq_unregister_notifier(&inf->freq_transition, CPUFREQ_TRANSITION_NOTIFIER);
2108   #endif
2109
2110         if (inf->clk)
2111     {
2112                 clk_disable(inf->clk);
2113                 clk_put(inf->clk);
2114                 inf->clk = NULL;
2115         }
2116     if (inf->dclk)
2117     {
2118                 clk_disable(inf->dclk);
2119                 clk_put(inf->dclk);
2120                 inf->dclk = NULL;
2121         }
2122
2123     kfree(inf);
2124     platform_set_drvdata(pdev, NULL);
2125
2126     return 0;
2127 }
2128
2129 static void rk29fb_shutdown(struct platform_device *pdev)
2130 {
2131     struct rk29fb_inf *inf = platform_get_drvdata(pdev);
2132     mdelay(300);
2133         //printk("----------------------------rk29fb_shutdown----------------------------\n");
2134         set_lcd_pin(pdev, 0);
2135     if (inf->dclk)
2136     {
2137         clk_disable(inf->dclk);
2138     }
2139     if (inf->clk)
2140     {
2141         clk_disable(inf->clk);
2142     }
2143 }
2144
2145 static struct platform_driver rk29fb_driver = {
2146         .probe          = rk29fb_probe,
2147         .remove         = rk29fb_remove,
2148         .driver         = {
2149                 .name   = "rk29-fb",
2150                 .owner  = THIS_MODULE,
2151         },
2152         .shutdown   = rk29fb_shutdown,
2153 };
2154
2155 static int __init rk29fb_init(void)
2156 {
2157     return platform_driver_register(&rk29fb_driver);
2158 }
2159
2160 static void __exit rk29fb_exit(void)
2161 {
2162     platform_driver_unregister(&rk29fb_driver);
2163 }
2164
2165 //subsys_initcall(rk29fb_init);
2166
2167 module_init(rk29fb_init);
2168 module_exit(rk29fb_exit);
2169
2170
2171 MODULE_AUTHOR("  zyw@rock-chips.com");
2172 MODULE_DESCRIPTION("Driver for rk29 fb device");
2173 MODULE_LICENSE("GPL");
2174
2175