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