2 * drivers/video/rk29_fb.c
4 * Copyright (C) 2010 ROCKCHIP, Inc.
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.
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.
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/string.h>
21 #include <linux/slab.h>
22 #include <linux/delay.h>
23 #include <linux/device.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 #include <linux/wakelock.h>
39 #include <asm/div64.h>
40 #include <asm/uaccess.h>
48 #include <linux/completion.h>
50 #include <linux/hdmi.h>
53 #include <mach/iomux.h>
54 #include <mach/gpio.h>
55 #include <mach/board.h>
56 #include <mach/rk29_iomap.h>
58 #include <mach/rk29-ipp.h>
60 #include "./display/screen/screen.h"
62 #define ANDROID_USE_THREE_BUFS 0 //android use three buffers to accelerate UI display in rgb plane
63 #define CURSOR_BUF_SIZE 256 //RK2818 cursor need 256B buf
64 int rk29_cursor_buf[CURSOR_BUF_SIZE];
101 #define fbprintk(msg...) printk(msg);
103 #define fbprintk(msg...)
108 #define fbprintk2(msg...) printk(msg);
110 #define fbprintk2(msg...)
113 #define LcdReadBit(inf, addr, msk) ((inf->regbak.addr=inf->preg->addr)&(msk))
114 #define LcdWrReg(inf, addr, val) inf->preg->addr=inf->regbak.addr=(val)
115 #define LcdRdReg(inf, addr) (inf->preg->addr)
116 #define LcdSetBit(inf, addr, msk) inf->preg->addr=((inf->regbak.addr) |= (msk))
117 #define LcdClrBit(inf, addr, msk) inf->preg->addr=((inf->regbak.addr) &= ~(msk))
118 #define LcdSetRegBit(inf, addr, msk) inf->preg->addr=((inf->preg->addr) |= (msk))
119 #define LcdMskReg(inf, addr, msk, val) (inf->regbak.addr)&=~(msk); inf->preg->addr=(inf->regbak.addr|=(val))
122 #define IsMcuLandscape() ((SCREEN_MCU==inf->cur_screen->type) && (0==inf->mcu_scandir))
123 #define IsMcuUseFmk() ( (2==inf->cur_screen->mcu_usefmk) || (1==inf->cur_screen->mcu_usefmk))
125 #define CalScaleW0(x, y) (((u32)x*0x1000)/y)
128 struct fb_bitfield red;
129 struct fb_bitfield green;
130 struct fb_bitfield blue;
131 struct fb_bitfield transp;
134 static struct rk29fb_rgb def_rgb_16 = {
135 red: { offset: 11, length: 5, },
136 green: { offset: 5, length: 6, },
137 blue: { offset: 0, length: 5, },
138 transp: { offset: 0, length: 0, },
142 volatile u32 y_offset;
143 volatile u32 c_offset;
151 u32 xpos; //size in panel
153 u32 xsize; //start point in panel
157 wait_queue_head_t wait;
158 struct win_set mirror;
159 struct win_set displ;
184 void __iomem *reg_vir_base; // virtual basic address of lcdc register
185 u32 reg_phy_base; // physical basic address of lcdc register
186 u32 len; // physical map length of lcdc register
190 struct clk *dclk; //lcdc dclk
191 struct clk *dclk_parent; //lcdc dclk divider frequency source
192 struct clk *dclk_divider; //lcdc demodulator divider frequency
193 struct clk *aclk; //lcdc share memory frequency
194 struct clk *aclk_parent; //lcdc aclk divider frequency source
195 struct clk *aclk_ddr_lcdc; //DDR LCDC AXI clock disable.
196 struct clk *aclk_disp_matrix; //DISPLAY matrix AXI clock disable.
197 struct clk *hclk_cpu_display; //CPU DISPLAY AHB bus clock disable.
198 struct clk *pd_display; // display power domain
199 unsigned long dclk_rate;
201 /* lcdc reg base address and backup reg */
206 int fb0_color_deepth;
207 /* variable used in mcu panel */
211 struct timer_list mcutimer;
217 /* external memery */
218 char __iomem *screen_base2;
220 unsigned long smem_start2;
222 char __iomem *cursor_base; /* cursor Virtual address*/
223 __u32 cursor_size; /* Amount of ioremapped VRAM or 0 */
224 unsigned long cursor_start;
226 struct rk29fb_screen panel1_info; // 1st panel, it's lcd normally
227 struct rk29fb_screen panel2_info; // 2nd panel
228 struct rk29fb_screen *cur_screen;
229 #if 0 //def CONFIG_CPU_FREQ
230 struct notifier_block freq_transition;
235 typedef enum _TRSP_MODE
247 struct platform_device *g_pdev = NULL;
248 //static int win1fb_set_par(struct fb_info *info);
251 #define CHK_SUSPEND(inf) \
252 if(inf->in_suspend) { \
253 fbprintk(">>>>>> fb is in suspend! return! \n"); \
257 #define CHK_SUSPEND(inf)
260 static DECLARE_WAIT_QUEUE_HEAD(wq);
261 static int wq_condition = 0;
262 static int wq_condition2 = 0;
263 #if ANDROID_USE_THREE_BUFS
264 static int new_frame_seted = 1;
266 static struct wake_lock idlelock; /* only for fb */
268 void set_lcd_pin(struct platform_device *pdev, int enable)
270 struct rk29fb_info *mach_info = pdev->dev.platform_data;
272 unsigned display_on = mach_info->disp_on_pin;
273 unsigned lcd_standby = mach_info->standby_pin;
275 int display_on_pol = mach_info->disp_on_value;
276 int lcd_standby_pol = mach_info->standby_value;
278 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
279 fbprintk(">>>>>> display_on(%d) = %d \n", display_on, enable ? display_on_pol : !display_on_pol);
280 fbprintk(">>>>>> lcd_standby(%d) = %d \n", lcd_standby, enable ? lcd_standby_pol : !lcd_standby_pol);
284 if(display_on != INVALID_GPIO)
286 gpio_direction_output(display_on, 0);
287 gpio_set_value(display_on, enable ? display_on_pol : !display_on_pol);
289 if(lcd_standby != INVALID_GPIO)
291 gpio_direction_output(lcd_standby, 0);
292 gpio_set_value(lcd_standby, enable ? lcd_standby_pol : !lcd_standby_pol);
296 int mcu_do_refresh(struct rk29fb_inf *inf)
298 if(inf->mcu_stopflush) return 0;
300 if(SCREEN_MCU!=inf->cur_screen->type) return 0;
305 inf->mcu_needflush = 1;
309 // not use frame mark
310 if(LcdReadBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_SELECT))
312 if(!LcdReadBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST))
314 inf->mcu_needflush = 1;
318 if(inf->cur_screen->refresh) inf->cur_screen->refresh(REFRESH_PRE);
319 inf->mcu_needflush = 0;
321 LcdSetRegBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST);
328 void mcutimer_callback(unsigned long arg)
330 struct rk29fb_inf *inf = platform_get_drvdata(g_pdev);
331 static int waitcnt = 0;
333 mod_timer(&inf->mcutimer, jiffies + HZ/10);
335 switch(inf->mcu_status)
338 inf->mcu_status = MS_MCU;
341 if(inf->mcu_usetimer) mcu_do_refresh(inf);
344 inf->mcu_status = MS_EWAITEND;
352 inf->mcu_status = MS_EEND;
356 inf->mcu_status = MS_MCU;
359 inf->mcu_status = MS_MCU;
364 int mcu_refresh(struct rk29fb_inf *inf)
366 static int mcutimer_inited = 0;
368 if(SCREEN_MCU!=inf->cur_screen->type) return 0;
373 init_timer(&inf->mcutimer);
374 inf->mcutimer.function = mcutimer_callback;
375 inf->mcutimer.expires = jiffies + HZ/5;
376 inf->mcu_status = MS_IDLE;
377 add_timer(&inf->mcutimer);
380 if(MS_MCU==inf->mcu_status) mcu_do_refresh(inf);
385 int mcu_ioctl(unsigned int cmd, unsigned long arg)
387 struct rk29fb_inf *inf = NULL;
388 if(!g_pdev) return -1;
390 inf = dev_get_drvdata(&g_pdev->dev);
395 LcdClrBit(inf, MCU_TIMING_CTRL, m_MCU_RS_SELECT);
396 LcdWrReg(inf, MCU_BYPASS_WPORT, arg);
397 LcdSetBit(inf, MCU_TIMING_CTRL, m_MCU_RS_SELECT);
401 LcdSetBit(inf, MCU_TIMING_CTRL, m_MCU_RS_SELECT);
402 LcdWrReg(inf, MCU_BYPASS_WPORT, arg);
406 LcdMskReg(inf, MCU_TIMING_CTRL, m_MCU_BYPASSMODE_SELECT, v_MCU_BYPASSMODE_SELECT(arg));
407 LcdWrReg(inf, REG_CFG_DONE, 0x01);
417 static irqreturn_t mcu_irqfmk(int irq, void *dev_id)
419 struct platform_device *pdev = (struct platform_device*)dev_id;
420 struct rk29fb_inf *inf = platform_get_drvdata(pdev);
421 struct rk29fb_screen *screen;
423 if(!inf) return IRQ_HANDLED;
425 screen = inf->cur_screen;
427 if(0==screen->mcu_usefmk) {
431 if(inf->mcu_fmksync == 1)
434 inf->mcu_fmksync = 1;
435 if(inf->mcu_needflush)
437 inf->mcu_needflush = 0;
439 if(inf->cur_screen->refresh)
440 inf->cur_screen->refresh(REFRESH_PRE);
441 LcdSetBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST);
443 inf->mcu_fmksync = 0;
448 int init_lcdc(struct fb_info *info)
450 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
453 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
455 inf->clk = clk_get(NULL, "hclk_lcdc");
456 inf->aclk_ddr_lcdc = clk_get(NULL, "aclk_ddr_lcdc");
457 inf->aclk_disp_matrix = clk_get(NULL, "aclk_disp_matrix");
458 inf->hclk_cpu_display = clk_get(NULL, "hclk_cpu_display");
459 inf->pd_display = clk_get(NULL, "pd_display");
460 if ((IS_ERR(inf->clk)) ||
461 (IS_ERR(inf->aclk_ddr_lcdc)) ||
462 (IS_ERR(inf->aclk_disp_matrix)) ||
463 (IS_ERR(inf->hclk_cpu_display)) ||
464 (IS_ERR(inf->pd_display)))
466 printk(KERN_ERR "failed to get lcdc_hclk source\n");
467 return PTR_ERR(inf->clk);
469 clk_enable(inf->aclk_disp_matrix);
470 clk_enable(inf->hclk_cpu_display);
471 clk_enable(inf->clk);
472 clk_enable(inf->pd_display);
473 //pmu_set_power_domain(PD_DISPLAY, 1);
474 clk_enable(inf->aclk_ddr_lcdc);
476 // set AHB access rule and disable all windows
477 LcdWrReg(inf, SYS_CONFIG, 0x60000000);
478 LcdWrReg(inf, SWAP_CTRL, 0);
479 LcdWrReg(inf, FIFO_WATER_MARK, 0x00000862);//68
480 LcdWrReg(inf, AXI_MS_ID, 0x54321);
482 // and mcu holdmode; and set win1 top.
483 LcdMskReg(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_SELECT | m_MCU_HOLDMODE_FRAME_ST | m_MCU_BYPASSMODE_SELECT ,
484 v_MCU_HOLDMODE_SELECT(0)| v_MCU_HOLDMODE_FRAME_ST(0) |v_MCU_BYPASSMODE_SELECT(0));
486 // disable blank out, black out, tristate out, yuv2rgb bypass
487 LcdMskReg(inf, BLEND_CTRL,m_W2_BLEND_EN | m_W1_BLEND_EN | m_W0_BLEND_EN | m_HWC_BLEND_EN |
488 m_HWC_BLEND_FACTOR | m_W1_BLEND_FACTOR | m_W0_BLEND_FACTOR,
489 v_W2_BLEND_EN(0) |v_W1_BLEND_EN(0) | v_W0_BLEND_EN(0) | v_HWC_BLEND_EN(0) |
490 v_HWC_BLEND_FACTOR(0) | v_W2_BLEND_FACTOR(0) | v_W1_BLEND_FACTOR(0) | v_W0_BLEND_FACTOR(0)
493 LcdMskReg(inf, WIN0_COLOR_KEY_CTRL, m_COLORKEY_EN, v_COLORKEY_EN(0));
494 LcdMskReg(inf, WIN1_COLOR_KEY_CTRL, m_COLORKEY_EN, v_COLORKEY_EN(0));
496 LcdWrReg(inf, DSP_CTRL1, 0);
498 // initialize all interrupt
499 clr = v_HOR_STARTCLEAR(1) | v_FRM_STARTCLEAR(1) | v_SCANNING_CLEAR(1);
501 msk = v_HOR_STARTMASK(1) | v_FRM_STARTMASK(0) | v_SCANNING_MASK(1);
503 LcdWrReg(inf, INT_STATUS, clr | msk);
505 // let above to take effect
506 LcdWrReg(inf, REG_CFG_DONE, 0x01);
511 void load_screen(struct fb_info *info, bool initscreen)
514 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
515 struct rk29fb_screen *screen = inf->cur_screen;
517 u16 mcu_total, mcu_rwstart, mcu_csstart, mcu_rwend, mcu_csend;
518 u16 right_margin = screen->right_margin, lower_margin = screen->lower_margin;
519 u16 x_res = screen->x_res, y_res = screen->y_res;
520 u32 aclk_rate = 150000000;
523 printk(">>>>>> %s : %s no g_pdev\n", __FILE__, __FUNCTION__);
527 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
529 // set the rgb or mcu
530 LcdMskReg(inf, MCU_TIMING_CTRL, m_MCU_OUTPUT_SELECT, v_MCU_OUTPUT_SELECT((SCREEN_MCU==screen->type)?(1):(0)));
532 // set out format and mcu timing
533 mcu_total = (screen->mcu_wrperiod*150*1000)/1000000;
534 if(mcu_total>31) mcu_total = 31;
535 if(mcu_total<3) mcu_total = 3;
536 mcu_rwstart = (mcu_total+1)/4 - 1;
537 mcu_rwend = ((mcu_total+1)*3)/4 - 1;
538 mcu_csstart = (mcu_rwstart>2) ? (mcu_rwstart-3) : (0);
539 mcu_csend = (mcu_rwend>15) ? (mcu_rwend-1) : (mcu_rwend);
541 fbprintk(">> mcu_total=%d, mcu_rwstart=%d, mcu_csstart=%d, mcu_rwend=%d, mcu_csend=%d \n",
542 mcu_total, mcu_rwstart, mcu_csstart, mcu_rwend, mcu_csend);
544 LcdMskReg(inf, MCU_TIMING_CTRL,
545 m_MCU_CS_ST | m_MCU_CS_END| m_MCU_RW_ST | m_MCU_RW_END |
546 m_MCU_WRITE_PERIOD | m_MCU_HOLDMODE_SELECT | m_MCU_HOLDMODE_FRAME_ST,
547 v_MCU_CS_ST(mcu_csstart) | v_MCU_CS_END(mcu_csend) | v_MCU_RW_ST(mcu_rwstart) |
548 v_MCU_RW_END(mcu_rwend) | v_MCU_WRITE_PERIOD(mcu_total) |
549 v_MCU_HOLDMODE_SELECT((SCREEN_MCU==screen->type)?(1):(0)) | v_MCU_HOLDMODE_FRAME_ST(0)
552 // set synchronous pin polarity and data pin swap rule
553 switch (screen->face)
557 LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
561 LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
565 LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(0));
569 LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(1) | v_DITHER_DOWN_MODE(1));
573 LcdMskReg(inf, DSP_CTRL0, m_DITHER_UP_EN, v_DITHER_UP_EN(1));
574 LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(0) | v_DITHER_DOWN_MODE(0));
577 LcdMskReg(inf, DSP_CTRL0, m_DITHER_UP_EN, v_DITHER_UP_EN(0));
578 LcdMskReg(inf, DSP_CTRL0, m_DITHER_DOWN_EN | m_DITHER_DOWN_MODE, v_DITHER_DOWN_EN(0) | v_DITHER_DOWN_MODE(0));
583 LcdMskReg(inf, DSP_CTRL0,
584 m_DISPLAY_FORMAT | m_HSYNC_POLARITY | m_VSYNC_POLARITY | m_DEN_POLARITY |
585 m_DCLK_POLARITY | m_COLOR_SPACE_CONVERSION,
586 v_DISPLAY_FORMAT(face) | v_HSYNC_POLARITY(screen->pin_hsync) | v_VSYNC_POLARITY(screen->pin_vsync) |
587 v_DEN_POLARITY(screen->pin_den) | v_DCLK_POLARITY(screen->pin_dclk) | v_COLOR_SPACE_CONVERSION(0)
590 LcdMskReg(inf, DSP_CTRL1, m_BG_COLOR, v_BG_COLOR(0x000000) );
592 LcdMskReg(inf, SWAP_CTRL, m_OUTPUT_RB_SWAP | m_OUTPUT_RG_SWAP | m_DELTA_SWAP | m_DUMMY_SWAP,
593 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));
595 // set horizontal & vertical out timing
596 if(SCREEN_MCU==inf->cur_screen->type)
598 right_margin = x_res/6;
601 fbprintk("screen->hsync_len =%d, screen->left_margin =%d, x_res =%d, right_margin = %d \n",
602 screen->hsync_len , screen->left_margin , x_res , right_margin );
603 LcdMskReg(inf, DSP_HTOTAL_HS_END, m_BIT12LO | m_BIT12HI, v_BIT12LO(screen->hsync_len) |
604 v_BIT12HI(screen->hsync_len + screen->left_margin + x_res + right_margin));
605 LcdMskReg(inf, DSP_HACT_ST_END, m_BIT12LO | m_BIT12HI, v_BIT12LO(screen->hsync_len + screen->left_margin + x_res) |
606 v_BIT12HI(screen->hsync_len + screen->left_margin));
608 LcdMskReg(inf, DSP_VTOTAL_VS_END, m_BIT11LO | m_BIT11HI, v_BIT11LO(screen->vsync_len) |
609 v_BIT11HI(screen->vsync_len + screen->upper_margin + y_res + lower_margin));
610 LcdMskReg(inf, DSP_VACT_ST_END, m_BIT11LO | m_BIT11HI, v_BIT11LO(screen->vsync_len + screen->upper_margin+y_res)|
611 v_BIT11HI(screen->vsync_len + screen->upper_margin));
613 LcdMskReg(inf, DSP_VS_ST_END_F1, m_BIT11LO | m_BIT11HI, v_BIT11LO(0) | v_BIT11HI(0));
614 LcdMskReg(inf, DSP_VACT_ST_END_F1, m_BIT11LO | m_BIT11HI, v_BIT11LO(0) | v_BIT11HI(0));
616 // let above to take effect
617 LcdWrReg(inf, REG_CFG_DONE, 0x01);
619 inf->dclk = clk_get(NULL, "dclk_lcdc");
620 if (IS_ERR(inf->dclk))
622 printk(KERN_ERR "failed to get lcd dclock source\n");
625 inf->dclk_divider= clk_get(NULL, "dclk_lcdc_div");
626 if (IS_ERR(inf->dclk_divider))
628 printk(KERN_ERR "failed to get lcd clock lcdc_divider source \n");
632 if((inf->cur_screen->type == SCREEN_HDMI) || (inf->cur_screen->type == SCREEN_TVOUT)){
633 inf->dclk_parent = clk_get(NULL, "codec_pll");
634 clk_set_rate(inf->dclk_parent, 594000000);
636 inf->dclk_parent = clk_get(NULL, "general_pll");
639 if (IS_ERR(inf->dclk_parent))
641 printk(KERN_ERR "failed to get lcd dclock parent source\n");
645 inf->aclk = clk_get(NULL, "aclk_lcdc");
646 if (IS_ERR(inf->aclk))
648 printk(KERN_ERR "failed to get lcd clock clk_share_mem source \n");
651 inf->aclk_parent = clk_get(NULL, "ddr_pll");//general_pll //ddr_pll
652 if (IS_ERR(inf->dclk_parent))
654 printk(KERN_ERR "failed to get lcd dclock parent source\n");
659 if(SCREEN_MCU==screen->type) screen->pixclock = 150000000; //mcu fix to 150 MHz
661 if(initscreen == 0) //not init
663 clk_disable(inf->dclk);
664 clk_disable(inf->aclk);
667 clk_disable(inf->aclk_ddr_lcdc);
668 clk_disable(inf->aclk_disp_matrix);
669 clk_disable(inf->hclk_cpu_display);
671 clk_disable(inf->clk);
672 clk_set_parent(inf->dclk_divider, inf->dclk_parent);
673 clk_set_parent(inf->dclk, inf->dclk_divider);
674 ret = clk_set_parent(inf->aclk, inf->aclk_parent);
676 fbprintk(">>>>>> set lcdc dclk need %d HZ, clk_parent = %d hz ret =%d\n ", screen->pixclock, screen->lcdc_aclk, ret);
678 ret = clk_set_rate(inf->dclk_divider, screen->pixclock);
681 printk(KERN_ERR ">>>>>> set lcdc dclk_divider faild \n ");
684 if(screen->lcdc_aclk){
685 aclk_rate = screen->lcdc_aclk;
687 ret = clk_set_rate(inf->aclk, aclk_rate);
689 printk(KERN_ERR ">>>>>> set lcdc dclk_divider faild \n ");
692 clk_enable(inf->aclk_ddr_lcdc);
693 clk_enable(inf->aclk_disp_matrix);
694 clk_enable(inf->hclk_cpu_display);
696 clk_enable(inf->aclk);
697 clk_enable(inf->clk);
698 clk_enable(inf->dclk);
706 #if 0 //def CONFIG_CPU_FREQ
708 * CPU clock speed change handler. We need to adjust the LCD timing
709 * parameters when the CPU clock is adjusted by the power management
712 #define TO_INF(ptr,member) container_of(ptr,struct rk29fb_inf,member)
715 rk29fb_freq_transition(struct notifier_block *nb, unsigned long val, void *data)
717 struct rk29fb_inf *inf = TO_INF(nb, freq_transition);
718 struct rk29fb_screen *screen = inf->cur_screen;
723 case CPUFREQ_PRECHANGE:
725 case CPUFREQ_POSTCHANGE:
727 dclk_rate = screen->pixclock * 1000000;
729 fbprintk(">>>>>> set lcdc dclk need %d HZ, clk_parent = %d hz \n ", screen->pixclock, dclk_rate);
731 clk_set_rate(inf->dclk_divider, dclk_rate);
739 static inline unsigned int chan_to_field(unsigned int chan,
740 struct fb_bitfield *bf)
743 chan >>= 16 - bf->length;
744 return chan << bf->offset;
747 static int fb_setcolreg(unsigned regno,
748 unsigned red, unsigned green, unsigned blue,
749 unsigned transp, struct fb_info *info)
752 // fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
754 switch (info->fix.visual) {
755 case FB_VISUAL_TRUECOLOR:
756 /* true-colour, use pseudo-palette */
758 u32 *pal = info->pseudo_palette;
759 val = chan_to_field(red, &info->var.red);
760 val |= chan_to_field(green, &info->var.green);
761 val |= chan_to_field(blue, &info->var.blue);
766 return -1; /* unknown type */
772 int rk29_set_cursor_en(struct rk29fb_inf *inf, int enable)
775 LcdSetBit(inf, SYS_CONFIG, m_HWC_ENABLE);
777 LcdClrBit(inf, SYS_CONFIG, m_HWC_ENABLE);
779 LcdWrReg(inf, REG_CFG_DONE, 0x01);
783 int rk29_set_cursor_pos(struct rk29fb_inf *inf, int x, int y)
785 struct rk29fb_screen *screen = inf->cur_screen;
788 if (x >= 0x800 || y >= 0x800 )
790 //printk("%s: %08x,%08x \n",__func__, x, y);
791 x += (screen->left_margin + screen->hsync_len);
792 y += (screen->upper_margin + screen->vsync_len);
793 LcdWrReg(inf, HWC_DSP_ST, v_BIT11LO(x)|v_BIT11HI(y));
794 LcdWrReg(inf, REG_CFG_DONE, 0x01);
799 int rk29_set_cursor_colour_map(struct rk29fb_inf *inf, int bg_col, int fg_col)
801 LcdMskReg(inf, HWC_COLOR_LUT0, m_HWC_R|m_HWC_G|m_HWC_B,bg_col);
802 LcdMskReg(inf, HWC_COLOR_LUT2, m_HWC_R|m_HWC_G|m_HWC_B,fg_col);
803 LcdWrReg(inf, REG_CFG_DONE, 0x01);
807 #define RK29_CURSOR_WRITE_BIT(addr,mask,value) (*((char*)addr)) = (((*((char*)addr))&(~((char)mask)))|((char)value))
808 int rk29_set_cursor_img_transform(char *data)
811 char *dst = (char*)rk29_cursor_buf;
812 unsigned char dmsk = 0;
813 unsigned int op,shift,offset;
815 /* rk29 cursor is a 2 bpp 32x32 bitmap this routine
816 * clears it to transparent then combines the cursor
817 * shape plane with the colour plane to set the
819 for (y = 0; y < 32; y++)
821 for (x = 0; x < 32; x++)
828 op = (dmsk & 0x80) ? 1 : 3;
831 RK29_CURSOR_WRITE_BIT((dst+offset),(3<<shift),(op<<shift));
841 int rk29_set_cursor_img(struct rk29fb_inf *inf, char *data)
845 rk29_set_cursor_img_transform(data);
849 rk29_set_cursor_img_transform(cursor_img);
851 LcdWrReg(inf, HWC_MST, __pa(rk29_cursor_buf));
852 LcdSetBit(inf, SYS_CONFIG,m_HWC_RELOAD_EN);
853 LcdWrReg(inf, REG_CFG_DONE, 0x01);
857 int rk29_set_cursor_test(struct fb_info *info)
859 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
860 rk29_set_cursor_colour_map(inf, 0x000000ff, 0x00ff0000);
861 rk29_set_cursor_pos(inf, 0, 0);
862 rk29_set_cursor_img(inf, 0);
863 rk29_set_cursor_en(inf, 1);
868 int rk29_set_cursor(struct fb_info *info, struct fb_cursor *cursor)
870 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
872 //fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
874 /* check not being asked to exceed capabilities */
876 if (cursor->image.width > 32)
879 if (cursor->image.height > 32)
882 if (cursor->image.depth > 1)
886 LcdSetBit(inf, SYS_CONFIG, m_HWC_ENABLE);
888 LcdClrBit(inf, SYS_CONFIG, m_HWC_ENABLE);
891 if (cursor->set & FB_CUR_SETPOS)
893 unsigned int x = cursor->image.dx;
894 unsigned int y = cursor->image.dy;
896 if (x >= 0x800 || y >= 0x800 )
898 LcdWrReg(inf, HWC_DSP_ST, v_BIT11LO(x)|v_BIT11HI(y));
902 if (cursor->set & FB_CUR_SETCMAP)
904 unsigned int bg_col = cursor->image.bg_color;
905 unsigned int fg_col = cursor->image.fg_color;
907 fbprintk("%s: update cmap (%08x,%08x)\n",
908 __func__, bg_col, fg_col);
910 LcdMskReg(inf, HWC_COLOR_LUT0, m_HWC_R|m_HWC_G|m_HWC_B,
911 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));
913 LcdMskReg(inf, HWC_COLOR_LUT2, m_HWC_R|m_HWC_G|m_HWC_B,
914 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));
917 if ((cursor->set & FB_CUR_SETSIZE ||
918 cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE))
919 && info->screen_base && info->fix.smem_start && info->fix.smem_len)
921 /* rk29 cursor is a 2 bpp 32x32 bitmap this routine
922 * clears it to transparent then combines the cursor
923 * shape plane with the colour plane to set the
926 const unsigned char *pcol = cursor->image.data;
927 const unsigned char *pmsk = cursor->mask;
929 unsigned long cursor_mem_start;
930 unsigned char dcol = 0;
931 unsigned char dmsk = 0;
934 dst = info->screen_base + info->fix.smem_len - CURSOR_BUF_SIZE;
935 cursor_mem_start = info->fix.smem_start + info->fix.smem_len - CURSOR_BUF_SIZE;
937 fbprintk("%s: setting shape (%d,%d)\n",
938 __func__, cursor->image.width, cursor->image.height);
940 memset(dst, 0, CURSOR_BUF_SIZE);
942 for (y = 0; y < cursor->image.height; y++)
944 for (x = 0; x < cursor->image.width; x++)
955 op = (dcol & 1) ? 1 : 3;
956 op <<= ((x % 4) * 2);
957 *(u8*)(dst+(x/4)) |= op;
962 LcdSetBit(inf, SYS_CONFIG,m_HWC_RELOAD_EN);
963 LcdWrReg(inf, HWC_MST, cursor_mem_start);
964 // flush end when wq_condition=1 in mcu panel, but not in rgb panel
965 if(SCREEN_MCU == inf->cur_screen->type) {
966 wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
970 wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
972 LcdClrBit(inf, SYS_CONFIG, m_HWC_RELOAD_EN);
979 static int win0_blank(int blank_mode, struct fb_info *info)
981 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
983 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
989 case FB_BLANK_UNBLANK:
990 LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(1));
993 LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(0));
996 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1002 static int win0_set_par(struct fb_info *info)
1004 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1005 struct rk29fb_screen *screen = inf->cur_screen;
1006 struct fb_var_screeninfo *var = &info->var;
1007 struct fb_fix_screeninfo *fix = &info->fix;
1008 struct win0_par *par = info->par;
1010 u32 xact = var->xres; /* visible resolution */
1011 u32 yact = var->yres;
1012 u32 xvir = var->xres_virtual; /* virtual resolution */
1013 u32 yvir = var->yres_virtual;
1014 //u32 xact_st = var->xoffset; /* offset from virtual to visible */
1015 //u32 yact_st = var->yoffset; /* resolution */
1016 u32 xpos = par->xpos;
1017 u32 ypos = par->ypos;
1019 u32 ScaleYrgbX=0x1000,ScaleYrgbY=0x1000;
1020 u32 ScaleCbrX=0x1000, ScaleCbrY=0x1000;
1022 u32 y_addr = 0; //user alloc buf addr y
1025 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1029 // calculate the display phy address
1030 y_addr = fix->smem_start + par->y_offset;
1031 uv_addr = fix->mmio_start + par->c_offset;
1033 ScaleYrgbX = CalScaleW0(xact, par->xsize);
1034 ScaleYrgbY = CalScaleW0(yact, par->ysize);
1036 switch (par->format)
1039 ScaleCbrX= CalScaleW0((xact/2), par->xsize);
1040 ScaleCbrY = CalScaleW0(yact, par->ysize);
1044 ScaleCbrX= CalScaleW0(xact/2, par->xsize);
1045 ScaleCbrY = CalScaleW0(yact/2, par->ysize);
1048 ScaleCbrX= CalScaleW0(xact, par->xsize);
1049 ScaleCbrY = CalScaleW0(yact, par->ysize);
1055 xpos += (screen->left_margin + screen->hsync_len);
1056 ypos += (screen->upper_margin + screen->vsync_len);
1058 LcdWrReg(inf, WIN0_YRGB_MST, y_addr);
1059 LcdWrReg(inf, WIN0_CBR_MST, uv_addr);
1061 LcdMskReg(inf, SYS_CONFIG, m_W0_FORMAT , v_W0_FORMAT(par->format));//(inf->video_mode==0)
1063 LcdMskReg(inf, WIN0_VIR, m_WORDLO | m_WORDHI, v_VIRWIDTH(xvir) | v_VIRHEIGHT((yvir)) );
1064 LcdMskReg(inf, WIN0_ACT_INFO, m_WORDLO | m_WORDHI, v_WORDLO(xact) | v_WORDHI(yact));
1065 LcdMskReg(inf, WIN0_DSP_ST, m_BIT11LO | m_BIT11HI, v_BIT11LO(xpos) | v_BIT11HI(ypos));
1066 LcdMskReg(inf, WIN0_DSP_INFO, m_BIT12LO | m_BIT12HI, v_BIT12LO(par->xsize) | v_BIT12HI(par->ysize));
1067 LcdMskReg(inf, WIN0_SCL_FACTOR_YRGB, m_WORDLO | m_WORDHI, v_WORDLO(ScaleYrgbX) | v_WORDHI(ScaleYrgbY));
1068 LcdMskReg(inf, WIN0_SCL_FACTOR_CBR, m_WORDLO | m_WORDHI, v_WORDLO(ScaleCbrX) | v_WORDHI(ScaleCbrY));
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(1) | v_W0_YRGB_16_SWAP(1) | v_W0_YRGB_R_SHIFT_SWAP(1) | v_W0_565_RB_SWAP(0) | v_W0_YRGB_M8_SWAP(0) | v_W0_CBR_8_SWAP(0));
1077 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,
1078 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));
1081 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,
1082 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) |
1083 v_W0_YRGB_M8_SWAP((var->rotate==0)) | v_W0_CBR_8_SWAP(0));
1086 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,
1087 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) );
1091 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1097 static int win0_pan( struct fb_info *info )
1099 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1100 // struct fb_var_screeninfo *var0 = &info->var;
1101 struct fb_fix_screeninfo *fix0 = &info->fix;
1102 struct win0_par *par = info->par;
1103 u32 y_addr=0, uv_addr=0;
1105 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1109 y_addr = fix0->smem_start + par->y_offset;//y_offset;
1110 uv_addr = fix0->mmio_start + par->c_offset ;//c_offset;
1112 LcdWrReg(inf, WIN0_YRGB_MST, y_addr);
1113 LcdWrReg(inf, WIN0_CBR_MST, uv_addr);
1114 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1116 // enable win0 after the win0 addr is seted
1117 LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE((1==par->addr_seted)?(1):(0)));
1123 static int win1_blank(int blank_mode, struct fb_info *info)
1125 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1127 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1133 case FB_BLANK_UNBLANK:
1134 LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(1));
1137 LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(0));
1140 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1146 static int win1_set_par(struct fb_info *info)
1148 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1149 struct fb_fix_screeninfo *fix = &info->fix;
1150 struct rk29fb_screen *screen = inf->cur_screen;
1151 struct win0_par *par = info->par;
1152 struct fb_var_screeninfo *var = &info->var;
1154 //u32 offset=0, addr=0, map_size=0, smem_len=0;
1156 u16 xres_virtual = 0; //virtual screen size
1158 //u16 xpos_virtual = var->xoffset; //visiable offset in virtual screen
1159 //u16 ypos_virtual = var->yoffset;
1161 u16 xpos = par->xpos; //visiable offset in panel
1162 u16 ypos = par->ypos;
1164 u8 trspmode = TRSP_CLOSE;
1167 //fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1169 #ifdef CONFIG_FB_WORK_IPP
1170 if(((screen->x_res != var->xres) || (screen->y_res != var->yres))
1171 && !((screen->x_res>1280) && (var->bits_per_pixel == 32)))
1173 addr = fix->mmio_start + par->y_offset;
1174 xres_virtual = screen->x_res; //virtual screen size
1179 addr = fix->smem_start + par->y_offset;
1180 xres_virtual = var->xres_virtual; //virtual screen size
1182 LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE|m_W1_FORMAT, v_W1_ENABLE(1)|v_W1_FORMAT(par->format));
1184 xpos += (screen->left_margin + screen->hsync_len);
1185 ypos += (screen->upper_margin + screen->vsync_len);
1187 LcdWrReg(inf, WIN1_YRGB_MST, addr);
1189 LcdMskReg(inf, WIN1_DSP_ST, m_BIT11LO|m_BIT11HI, v_BIT11LO(xpos) | v_BIT11HI(ypos));
1190 LcdMskReg(inf, WIN1_DSP_INFO, m_BIT12LO|m_BIT12HI, v_BIT12LO(par->xsize) | v_BIT12HI(par->ysize));
1192 LcdMskReg(inf, WIN1_VIR, m_WORDLO , v_WORDLO(xres_virtual));
1194 LcdMskReg(inf, BLEND_CTRL, m_W1_BLEND_EN | m_W1_BLEND_FACTOR,
1195 v_W1_BLEND_EN((TRSP_FMREG==trspmode) || (TRSP_MASK==trspmode)) | v_W1_BLEND_FACTOR(trspval));
1197 // enable win1 color key and set the color to black(rgb=0)
1198 LcdMskReg(inf, WIN1_COLOR_KEY_CTRL, m_COLORKEY_EN | m_KEYCOLOR, v_COLORKEY_EN(1) | v_KEYCOLOR(0));
1200 if(1==par->format) //rgb565
1202 LcdMskReg(inf, SWAP_CTRL, m_W1_8_SWAP | m_W1_16_SWAP | m_W1_R_SHIFT_SWAP | m_W1_565_RB_SWAP,
1203 v_W1_8_SWAP(0) | v_W1_16_SWAP(0) | v_W1_R_SHIFT_SWAP(0) | v_W1_565_RB_SWAP(0) );
1207 LcdMskReg(inf, SWAP_CTRL, m_W1_8_SWAP | m_W1_16_SWAP | m_W1_R_SHIFT_SWAP | m_W1_565_RB_SWAP,
1208 v_W1_8_SWAP(1) | v_W1_16_SWAP(1) | v_W1_R_SHIFT_SWAP(1) | v_W1_565_RB_SWAP(0) );
1210 LcdMskReg(inf, DSP_CTRL0, m_W1_TRANSP_FROM, v_W1_TRANSP_FROM(TRSP_FMRAM==trspmode) );
1213 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1218 static int win1_pan( struct fb_info *info )
1220 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1221 struct fb_fix_screeninfo *fix1 = &info->fix;
1222 struct win0_par *par = info->par;
1225 #ifdef CONFIG_FB_WORK_IPP
1226 struct rk29fb_screen *screen = inf->cur_screen;
1227 struct fb_var_screeninfo *var = &info->var;
1228 if(((screen->x_res != var->xres) || (screen->y_res != var->yres))
1229 && !((screen->x_res>1280) && (var->bits_per_pixel == 32)))
1231 addr = fix1->mmio_start + par->y_offset;
1236 addr = fix1->smem_start + par->y_offset;
1239 //fbprintk("info->screen_base = %8x ; fix1->smem_len = %d , addr = %8x\n",(u32)info->screen_base, fix1->smem_len, addr);
1241 LcdWrReg(inf, WIN1_YRGB_MST, addr);
1242 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1248 static int fb0_blank(int blank_mode, struct fb_info *info)
1250 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1252 if(inf->video_mode == 1)
1254 win1_blank(blank_mode, info);
1258 win0_blank(blank_mode, info);
1263 static int fb0_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1265 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1266 struct rk29fb_screen *screen = inf->cur_screen;
1267 u16 xpos = (var->nonstd>>8) & 0xfff;
1268 u16 ypos = (var->nonstd>>20) & 0xfff;
1269 u16 xlcd = screen->x_res;
1270 u16 ylcd = screen->y_res;
1272 //fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1276 if( 0==var->xres_virtual || 0==var->yres_virtual ||
1277 0==var->xres || 0==var->yres || var->xres<16 ||
1278 ((16!=var->bits_per_pixel)&&(32!=var->bits_per_pixel)) )
1280 printk(">>>>>> win1fb_check_var fail 1!!! \n");
1281 printk(">>>>>> 0==%d || 0==%d ", var->xres_virtual,var->yres_virtual);
1282 printk("0==%d || 0==%d || %d<16 || ", var->xres,var->yres,var->xres<16);
1283 printk("bits_per_pixel=%d \n", var->bits_per_pixel);
1287 if( (var->xoffset+var->xres)>var->xres_virtual ||
1288 (var->yoffset+var->yres)>var->yres_virtual )
1290 printk(">>>>>> win1fb_check_var fail 2!!! \n");
1291 printk(">>>>>> (%d+%d)>%d || ", var->xoffset,var->xres,var->xres_virtual);
1292 printk("(%d+%d)>%d || ", var->yoffset,var->yres,var->yres_virtual);
1293 printk("(%d+%d)>%d || (%d+%d)>%d \n", xpos,var->xres,xlcd,ypos,var->yres,ylcd);
1297 if(inf->fb0_color_deepth)var->bits_per_pixel=inf->fb0_color_deepth;
1298 switch(var->bits_per_pixel)
1301 var->xres_virtual = (var->xres_virtual + 0x1) & (~0x1);
1302 var->xres = (var->xres + 0x1) & (~0x1);
1303 var->xoffset = (var->xoffset) & (~0x1);
1306 var->bits_per_pixel = 32;
1314 static int fb0_set_par(struct fb_info *info)
1316 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1317 struct fb_var_screeninfo *var = &info->var;
1318 struct fb_fix_screeninfo *fix = &info->fix;
1319 struct rk29fb_screen *screen = inf->cur_screen;
1320 struct win0_par *par = info->par;
1322 u32 offset=0, smem_len=0;
1323 u16 xres_virtual = var->xres_virtual; //virtual screen size
1324 u16 xpos_virtual = var->xoffset; //visiable offset in virtual screen
1325 u16 ypos_virtual = var->yoffset;
1327 #ifdef CONFIG_FB_WORK_IPP
1328 struct rk29_ipp_req ipp_req;
1332 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1336 if(inf->fb0_color_deepth)var->bits_per_pixel=inf->fb0_color_deepth;
1337 #if !defined(CONFIG_FB_WORK_IPP)
1338 if((inf->video_mode == 1)&&(screen->y_res < var->yres))ypos_virtual += (var->yres-screen->y_res);
1341 switch(var->bits_per_pixel)
1345 //fix->line_length = 2 * xres_virtual;
1346 fix->line_length = (inf->fb0_color_deepth ? 4:2) * xres_virtual; //32bit and 16bit change
1348 #ifdef CONFIG_FB_WORK_IPP
1349 dstoffset = ((ypos_virtual*screen->y_res/var->yres) *screen->x_res + (xpos_virtual*screen->x_res)/var->xres )*2;
1350 ipp_req.src0.fmt = IPP_RGB_565;
1351 ipp_req.dst0.fmt = IPP_RGB_565;
1353 offset = (ypos_virtual*xres_virtual + xpos_virtual)*(inf->fb0_color_deepth ? 4:2);
1358 fix->line_length = 4 * xres_virtual;
1359 #ifdef CONFIG_FB_WORK_IPP
1360 dstoffset = ((ypos_virtual*screen->y_res/var->yres) *screen->x_res + (xpos_virtual*screen->x_res)/var->xres )*4;
1361 ipp_req.src0.fmt = IPP_XRGB_8888;
1362 ipp_req.dst0.fmt = IPP_XRGB_8888;
1364 offset = (ypos_virtual*xres_virtual + xpos_virtual)*4;
1368 smem_len = fix->line_length * var->yres_virtual;
1369 //map_size = PAGE_ALIGN(smem_len);
1371 if (smem_len > fix->smem_len) // buffer need realloc
1373 printk("%s sorry!!! win1 buf is not enough\n",__FUNCTION__);
1377 par->addr_seted = 1;
1378 #if ANDROID_USE_THREE_BUFS
1379 if(0==new_frame_seted) {
1381 wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
1383 new_frame_seted = 0;
1386 if(inf->video_mode == 1)
1388 #ifdef CONFIG_FB_WORK_IPP
1389 if(((screen->x_res != var->xres) || (screen->y_res != var->yres))
1390 && !((screen->x_res>1280) && (var->bits_per_pixel == 32)))
1394 par->xsize = screen->x_res;
1395 par->ysize = screen->y_res;
1396 par->y_offset = dstoffset;
1398 ipp_req.src0.YrgbMst = fix->smem_start + offset;
1399 ipp_req.src0.w = var->xres;
1400 ipp_req.src0.h = var->yres;
1402 ipp_req.dst0.YrgbMst = fix->mmio_start + dstoffset;
1403 ipp_req.dst0.w = screen->x_res;
1404 ipp_req.dst0.h = screen->y_res;
1406 ipp_req.src_vir_w = ipp_req.src0.w;
1407 ipp_req.dst_vir_w = ipp_req.dst0.w;
1408 ipp_req.timeout = 100;
1409 ipp_req.flag = IPP_ROT_0;
1410 ipp_do_blit(&ipp_req);
1414 par->y_offset = offset;
1415 par->xpos = (screen->x_res >= var->xres)?((screen->x_res - var->xres)/2):0; //visiable offset in panel
1416 par->ypos = (screen->y_res >= var->yres)?(screen->y_res - var->yres):0;
1417 par->xsize = var->xres; //visiable size in panel
1418 par->ysize = (screen->y_res >= var->yres) ? var->yres : screen->y_res;
1424 par->y_offset = offset;
1427 par->xsize = screen->x_res;
1428 par->ysize = screen->y_res;
1435 static int fb0_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
1438 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1439 struct fb_var_screeninfo *var1 = &info->var;
1440 struct rk29fb_screen *screen = inf->cur_screen;
1441 struct win0_par *par = info->par;
1444 u16 ypos_virtual = var->yoffset;
1445 u16 xpos_virtual = var->xoffset;
1446 #ifdef CONFIG_FB_WORK_IPP
1447 struct fb_fix_screeninfo *fix = &info->fix;
1448 struct rk29_ipp_req ipp_req;
1451 //fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1455 if(inf->fb0_color_deepth)var->bits_per_pixel=inf->fb0_color_deepth;
1456 #if !defined(CONFIG_FB_WORK_IPP)
1457 if((inf->video_mode == 1)&&(screen->y_res < var->yres))ypos_virtual += (var->yres-screen->y_res);
1460 switch(var1->bits_per_pixel)
1463 var->xoffset = (var->xoffset) & (~0x1);
1464 #ifdef CONFIG_FB_WORK_IPP
1465 dstoffset = ((ypos_virtual*screen->y_res/var->yres) *screen->x_res + (xpos_virtual*screen->x_res)/var->xres) * 2;
1466 ipp_req.src0.fmt = IPP_RGB_565;
1467 ipp_req.dst0.fmt = IPP_RGB_565;
1469 offset = (ypos_virtual*var1->xres_virtual + xpos_virtual)*(inf->fb0_color_deepth ? 4:2);
1472 #ifdef CONFIG_FB_WORK_IPP
1473 dstoffset = ((ypos_virtual*screen->y_res/var->yres) *screen->x_res + (xpos_virtual*screen->x_res)/var->xres )*4;
1474 ipp_req.src0.fmt = IPP_XRGB_8888;
1475 ipp_req.dst0.fmt = IPP_XRGB_8888;
1477 offset = (ypos_virtual*var1->xres_virtual + xpos_virtual)*4;
1483 if(inf->video_mode == 1)
1485 #ifdef CONFIG_FB_WORK_IPP
1486 if(((screen->x_res != var->xres) || (screen->y_res != var->yres))
1487 && !((screen->x_res>1280) && (var->bits_per_pixel == 32)))
1489 par->y_offset = dstoffset;
1491 ipp_req.src0.YrgbMst = fix->smem_start + offset;
1492 ipp_req.src0.w = var->xres;
1493 ipp_req.src0.h = var->yres;
1495 ipp_req.dst0.YrgbMst = fix->mmio_start + dstoffset;
1496 ipp_req.dst0.w = screen->x_res;
1497 ipp_req.dst0.h = screen->y_res;
1499 ipp_req.src_vir_w = ipp_req.src0.w;
1500 ipp_req.dst_vir_w = ipp_req.dst0.w;
1501 ipp_req.timeout = 100;
1502 ipp_req.flag = IPP_ROT_0;
1503 ipp_do_blit(&ipp_req);
1508 par->y_offset = offset;
1513 par->y_offset = offset;
1516 // flush end when wq_condition=1 in mcu panel, but not in rgb panel
1517 #if !ANDROID_USE_THREE_BUFS
1518 // flush end when wq_condition=1 in mcu panel, but not in rgb panel
1519 if(SCREEN_MCU == inf->cur_screen->type) {
1520 wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
1524 wait_event_interruptible_timeout(wq, wq_condition, HZ/20);
1530 static int fb0_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
1532 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1533 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1539 case FB0_IOCTL_STOP_TIMER_FLUSH: //stop timer flush mcu panel after android is runing
1542 inf->mcu_usetimer = 0;
1545 case FBIOPUT_16OR32:
1547 inf->fb0_color_deepth = arg;
1550 case FBIOPUT_FBPHYADD:
1551 return info->fix.smem_start;
1552 case FBIOGET_OVERLAY_STATE:
1553 return inf->video_mode;
1554 case FBIOGET_SCREEN_STATE:
1555 return inf->cur_screen->type;
1557 case FBIOPUT_SET_CURSOR_EN:
1560 if(copy_from_user(&en, (void*)arg, sizeof(int)))
1562 rk29_set_cursor_en(inf, en);
1565 case FBIOPUT_SET_CURSOR_POS:
1567 struct fbcurpos pos;
1568 if(copy_from_user(&pos, (void*)arg, sizeof(struct fbcurpos)))
1570 rk29_set_cursor_pos(inf, pos.x , pos.y);
1573 case FBIOPUT_SET_CURSOR_IMG:
1575 char cursor_buf[CURSOR_BUF_SIZE];
1576 if(copy_from_user(cursor_buf, (void*)arg, CURSOR_BUF_SIZE))
1578 rk29_set_cursor_img(inf, cursor_buf);
1581 case FBIOPUT_SET_CURSOR_CMAP:
1583 struct fb_image img;
1584 if(copy_from_user(&img, (void*)arg, sizeof(struct fb_image)))
1586 rk29_set_cursor_colour_map(inf, img.bg_color, img.fg_color);
1589 case FBIOPUT_GET_CURSOR_RESOLUTION:
1592 //struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1593 if(inf->fb1->var.rotate == 270) {
1594 panel_size[0] = inf->cur_screen->y_res; //inf->cur_screen->y_res; change for hdmi video size
1595 panel_size[1] = inf->cur_screen->x_res;
1597 panel_size[0] = inf->cur_screen->x_res;
1598 panel_size[1] = inf->cur_screen->y_res;
1600 if(copy_to_user((void*)arg, panel_size, 8)) return -EFAULT;
1603 case FBIOPUT_GET_CURSOR_EN:
1605 u32 en = (inf->regbak.SYS_CONFIG & m_HWC_ENABLE);
1606 if(copy_to_user((void*)arg, &en, 4)) return -EFAULT;
1615 static int fb1_blank(int blank_mode, struct fb_info *info)
1617 win0_blank(blank_mode, info);
1621 static int fb1_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1623 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1624 struct rk29fb_screen *screen = inf->cur_screen;
1626 u32 ScaleYRGBY=0x1000;
1627 u16 xpos = (var->nonstd>>8) & 0xfff; //offset in panel
1628 u16 ypos = (var->nonstd>>20) & 0xfff;
1629 u16 xsize = (var->grayscale>>8) & 0xfff; //visiable size in panel
1630 u16 ysize = (var->grayscale>>20) & 0xfff;
1631 u16 xlcd = screen->x_res; //size of panel
1632 u16 ylcd = screen->y_res;
1635 struct hdmi *hdmi = get_hdmi_struct(0);
1637 xpos = (xpos * screen->x_res) / inf->panel1_info.x_res;
1638 ypos = (ypos * screen->y_res) / inf->panel1_info.y_res;
1639 xsize = (xsize * screen->x_res) / inf->panel1_info.x_res;
1640 ysize = (ysize * screen->y_res) / inf->panel1_info.y_res;
1642 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1646 if( 0==var->xres_virtual || 0==var->yres_virtual ||
1647 0==var->xres || 0==var->yres || var->xres<16 ||
1648 0==xsize || 0==ysize || xsize<16 ||
1649 ((16!=var->bits_per_pixel)&&(32!=var->bits_per_pixel)) )
1651 printk(">>>>>> win0fb_check_var fail 1!!! \n");
1652 printk("0==%d || 0==%d || 0==%d || 0==%d || %d<16 \n ||0==%d || 0==%d || %d<16 ||((16!=%d)&&(32!=%d)) \n",
1653 var->xres_virtual, var->yres_virtual, var->xres, var->yres, var->xres, xsize, ysize, xsize,
1654 var->bits_per_pixel, var->bits_per_pixel);
1658 if( (var->xoffset+var->xres)>var->xres_virtual ||
1659 (var->yoffset+var->yres)>var->yres_virtual ||
1660 (xpos+xsize)>xlcd || (ypos+ysize)>ylcd )
1662 printk(">>>>>> win0fb_check_var fail 2!!! \n");
1663 printk("(%d+%d)>%d || (%d+%d)>%d || (%d+%d)>%d || (%d+%d)>%d \n ",
1664 var->xoffset, var->xres, var->xres_virtual, var->yoffset, var->yres,
1665 var->yres_virtual, xpos, xsize, xlcd, ypos, ysize, ylcd);
1669 switch(var->nonstd&0x0f)
1672 switch(var->bits_per_pixel)
1675 var->xres_virtual = (var->xres_virtual + 0x1) & (~0x1);
1676 var->xres = (var->xres + 0x1) & (~0x1);
1677 var->xoffset = (var->xoffset) & (~0x1);
1680 var->bits_per_pixel = 32;
1683 var->nonstd &= ~0xc0; //not support I2P in this format
1686 var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
1687 var->xres = (var->xres + 0x3) & (~0x3);
1688 var->xoffset = (var->xoffset) & (~0x3);
1691 var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
1692 var->yres_virtual = (var->yres_virtual + 0x1) & (~0x1);
1693 var->xres = (var->xres + 0x3) & (~0x3);
1694 var->yres = (var->yres + 0x1) & (~0x1);
1695 var->xoffset = (var->xoffset) & (~0x3);
1696 var->yoffset = (var->yoffset) & (~0x1);
1699 var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
1700 var->yres_virtual = (var->yres_virtual + 0x1) & (~0x1);
1701 var->xres = (var->xres + 0x3) & (~0x3);
1702 var->yres = (var->yres + 0x1) & (~0x1);
1703 var->xoffset = (var->xoffset) & (~0x3);
1704 var->yoffset = (var->yoffset) & (~0x1);
1705 var->nonstd &= ~0xc0; //not support I2P in this format
1709 var->xres_virtual = (var->xres_virtual + 0x3) & (~0x3);
1710 var->xres = (var->xres + 0x3) & (~0x3);
1711 var->xoffset = (var->xoffset) & (~0x3);
1712 var->nonstd &= ~0xc0; //not support I2P in this format
1715 printk(">>>>>> fb1 var->nonstd=%d is invalid! \n", var->nonstd);
1721 ScaleYRGBY = CalScaleW0(yres, ysize);
1723 if((ScaleYRGBY>0x8000) || (ScaleYRGBY<0x200))
1725 return -EINVAL; // multiple of scale down or scale up can't exceed 8
1728 if(inf->video_mode == 1) {
1729 if(hdmi_resolution_changed(hdmi,var->xres,var->yres, 1) == 1)
1731 LcdMskReg(inf, DSP_CTRL1, m_BLACK_MODE, v_BLACK_MODE(1));
1732 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1733 init_completion(&hdmi->complete);
1735 wait_for_completion_interruptible_timeout(&hdmi->complete,
1736 msecs_to_jiffies(10000));
1743 static int fb1_set_par(struct fb_info *info)
1745 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1746 struct rk29fb_screen *screen = inf->cur_screen;
1747 struct fb_var_screeninfo *var = &info->var;
1748 struct fb_fix_screeninfo *fix = &info->fix;
1749 struct win0_par *par = info->par;
1752 u32 cblen=0, crlen=0, map_size=0, smem_len=0;
1754 //u32 xact = var->xres; /* visible resolution */
1755 //u32 yact = var->yres;
1756 u32 xvir = var->xres_virtual; /* virtual resolution */
1757 u32 yvir = var->yres_virtual;
1758 u32 xact_st = var->xoffset; /* offset from virtual to visible */
1759 u32 yact_st = var->yoffset; /* resolution */
1761 u16 xpos = (var->nonstd>>8) & 0xfff; //visiable pos in panel
1762 u16 ypos = (var->nonstd>>20) & 0xfff;
1763 u16 xsize = (var->grayscale>>8) & 0xfff; //visiable size in panel
1764 u16 ysize = (var->grayscale>>20) & 0xfff;
1766 //u32 ScaleYrgbX=0x1000,ScaleYrgbY=0x1000;
1767 //u32 ScaleCbrX=0x1000, ScaleCbrY=0x1000;
1769 u8 data_format = var->nonstd&0x0f;
1770 // u32 win0_en = var->reserved[2];
1771 // u32 y_addr = var->reserved[3]; //user alloc buf addr y
1772 // u32 uv_addr = var->reserved[4];
1774 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
1778 xpos = (xpos * screen->x_res) / inf->panel1_info.x_res;
1779 ypos = (ypos * screen->y_res) / inf->panel1_info.y_res;
1780 xsize = (xsize * screen->x_res) / inf->panel1_info.x_res;
1781 ysize = (ysize * screen->y_res) / inf->panel1_info.y_res;
1783 /* calculate y_offset,c_offset,line_length,cblen and crlen */
1784 switch (data_format)
1787 switch(var->bits_per_pixel)
1791 fix->line_length = 2 * xvir;
1792 par->y_offset = (yact_st*xvir + xact_st)*2;
1796 fix->line_length = 4 * xvir;
1797 par->y_offset = (yact_st*xvir + xact_st)*4;
1805 fix->line_length = xvir;
1806 cblen = crlen = (xvir*yvir)/2;
1807 par->y_offset = yact_st*xvir + xact_st;
1808 par->c_offset = yact_st*xvir + xact_st;
1812 fix->line_length = xvir;
1813 cblen = crlen = (xvir*yvir)/4;
1815 par->y_offset = yact_st*xvir + xact_st;
1816 par->c_offset = (yact_st/2)*xvir + xact_st;
1821 fix->line_length = xvir;
1822 par->y_offset = (yact_st/2)*2*xvir + (xact_st)*2;
1823 par->c_offset = (yact_st/2)*xvir + xact_st;
1824 cblen = crlen = (xvir*yvir)/4;
1829 fix->line_length = xvir;
1830 par->y_offset = yact_st*xvir + xact_st;
1831 par->c_offset = yact_st*2*xvir + xact_st*2;
1832 cblen = crlen = (xvir*yvir);
1838 smem_len = fix->line_length * yvir + cblen + crlen;
1839 map_size = PAGE_ALIGN(smem_len);
1841 // fix->smem_start = y_addr;
1842 fix->smem_len = smem_len;
1843 // fix->mmio_start = uv_addr;
1845 // par->addr_seted = ((-1==(int)y_addr) || (0==(int)y_addr) || (win0_en==0)) ? 0 : 1;
1846 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);
1848 par->format = format;
1855 if ( wq_condition2 == 0 ) {
1856 wait_event_interruptible_timeout(wq, wq_condition2, HZ/20);
1863 static int fb1_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
1865 struct win0_par *par = info->par;
1866 // enable win0 after the win0 addr is seted
1873 int fb1_open(struct fb_info *info, int user)
1875 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1876 struct win0_par *par = info->par;
1878 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1881 par->addr_seted = 0;
1882 inf->video_mode = 1;
1885 printk(">>>>>> fb1 has opened! \n");
1889 win0_blank(FB_BLANK_POWERDOWN, info);
1894 int fb1_release(struct fb_info *info, int user)
1896 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1897 struct win0_par *par = info->par;
1898 struct fb_var_screeninfo *var0 = &info->var;
1900 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1904 inf->video_mode = 0;
1906 par->addr_seted = 0;
1907 win0_blank(FB_BLANK_POWERDOWN, info);
1908 win1_blank(FB_BLANK_POWERDOWN, info);
1909 // wait for lcdc stop access memory
1913 info->screen_base = 0;
1914 info->fix.smem_start = 0;
1915 info->fix.smem_len = 0;
1916 // clean the var param
1917 memset(var0, 0, sizeof(struct fb_var_screeninfo));
1923 static int fb1_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
1925 struct rk29fb_inf *inf = dev_get_drvdata(info->device);
1926 struct win0_par *par = info->par;
1927 struct fb_fix_screeninfo *fix0 = &info->fix;
1928 void __user *argp = (void __user *)arg;
1930 fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
1931 fbprintk("win0fb_ioctl cmd = %8x, arg = %8x \n", (u32)cmd, (u32)arg);
1937 case FB1_IOCTL_GET_PANEL_SIZE: //get panel size
1940 if(inf->fb1->var.rotate == 270) {
1941 panel_size[0] = inf->panel1_info.y_res; //inf->cur_screen->y_res; change for hdmi video size
1942 panel_size[1] = inf->panel1_info.x_res;
1944 panel_size[0] = inf->panel1_info.x_res;
1945 panel_size[1] = inf->panel1_info.y_res;
1948 if(copy_to_user(argp, panel_size, 8)) return -EFAULT;
1952 case FB1_IOCTL_SET_YUV_ADDR: //set y&uv address to register direct
1955 if (copy_from_user(yuv_phy, argp, 8))
1958 fix0->smem_start = yuv_phy[0];
1959 fix0->mmio_start = yuv_phy[1];
1960 yuv_phy[0] += par->y_offset;
1961 yuv_phy[1] += par->c_offset;
1963 LcdWrReg(inf, WIN0_YRGB_MST, yuv_phy[0]);
1964 LcdWrReg(inf, WIN0_CBR_MST, yuv_phy[1]);
1965 // enable win0 after the win0 par is seted
1966 LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(par->par_seted && par->addr_seted));
1967 par->addr_seted = 1;
1968 LcdWrReg(inf, REG_CFG_DONE, 0x01);
1969 if(par->par_seted) {
1970 unsigned long flags;
1972 if (par->mirror.c_offset) {
1973 ret = wait_event_interruptible_timeout(par->wait,
1974 (0 == par->mirror.c_offset), HZ/20);
1980 local_irq_save(flags);
1981 par->mirror.y_offset = yuv_phy[0];
1982 par->mirror.c_offset = yuv_phy[1];
1983 local_irq_restore(flags);
1986 //printk("0x%.8x 0x%.8x mirror\n", par->mirror.y_offset, par->mirror.c_offset);
1991 case FB1_IOCTL_SET_ROTATE: //change MCU panel scan direction
1992 fbprintk(">>>>>> change lcdc direction(%d) \n", (int)arg);
1995 case FB1_IOCTL_SET_WIN0_TOP:
1996 fbprintk(">>>>>> FB1_IOCTL_SET_WIN0_TOP %d\n",arg);
1997 LcdMskReg(inf, DSP_CTRL0, m_W0_ON_TOP, v_W0_ON_TOP(arg));
1998 LcdWrReg(inf, REG_CFG_DONE, 0x01);
2006 static struct fb_ops fb1_ops = {
2007 .owner = THIS_MODULE,
2008 .fb_open = fb1_open,
2009 .fb_release = fb1_release,
2010 .fb_check_var = fb1_check_var,
2011 .fb_set_par = fb1_set_par,
2012 .fb_blank = fb1_blank,
2013 .fb_pan_display = fb1_pan_display,
2014 .fb_ioctl = fb1_ioctl,
2015 .fb_setcolreg = fb_setcolreg,
2016 .fb_fillrect = cfb_fillrect,
2017 .fb_copyarea = cfb_copyarea,
2018 .fb_imageblit = cfb_imageblit,
2021 static struct fb_ops fb0_ops = {
2022 .owner = THIS_MODULE,
2023 .fb_check_var = fb0_check_var,
2024 .fb_set_par = fb0_set_par,
2025 .fb_blank = fb0_blank,
2026 .fb_pan_display = fb0_pan_display,
2027 .fb_ioctl = fb0_ioctl,
2028 .fb_setcolreg = fb_setcolreg,
2029 .fb_fillrect = cfb_fillrect,
2030 .fb_copyarea = cfb_copyarea,
2031 .fb_imageblit = cfb_imageblit,
2032 //.fb_cursor = rk29_set_cursor,
2036 enable: 1, switch to tv or hdmi; 0, switch to lcd
2038 int FB_Switch_Screen( struct rk29fb_screen *screen, u32 enable )
2040 struct rk29fb_inf *inf = platform_get_drvdata(g_pdev);
2041 // struct rk29fb_info *mach_info = g_pdev->dev.platform_data;
2043 memcpy(&inf->panel2_info, screen, sizeof( struct rk29fb_screen ));
2045 if(enable)inf->cur_screen = &inf->panel2_info;
2046 else inf->cur_screen = &inf->panel1_info;
2048 /* Black out, because some display device need clock to standby */
2049 //LcdMskReg(inf, DSP_CTRL_REG1, m_BLACK_OUT, v_BLACK_OUT(1));
2050 // LcdMskReg(inf, SYS_CONFIG, m_W0_ENABLE, v_W0_ENABLE(0));
2051 // LcdMskReg(inf, SYS_CONFIG, m_W1_ENABLE, v_W1_ENABLE(0));
2052 LcdMskReg(inf, DSP_CTRL1, m_BLACK_MODE, v_BLACK_MODE(1));
2053 LcdWrReg(inf, REG_CFG_DONE, 0x01);
2054 wake_lock(&idlelock);
2056 wake_unlock(&idlelock);
2058 if(inf->cur_screen->standby) inf->cur_screen->standby(1);
2059 // operate the display_on pin to power down the lcd
2060 set_lcd_pin(g_pdev, (enable==0));
2062 load_screen(inf->fb0, 0);
2065 fb1_set_par(inf->fb1);
2066 fb0_set_par(inf->fb0);
2067 LcdMskReg(inf, DSP_CTRL1, m_BLACK_MODE, v_BLACK_MODE(0));
2068 LcdWrReg(inf, REG_CFG_DONE, 0x01);
2072 static ssize_t dsp_win0_info_read(struct device *device,
2073 struct device_attribute *attr, char *buf)
2076 struct rk29fb_inf *inf = platform_get_drvdata(g_pdev);
2077 struct rk29fb_screen *screen = inf->cur_screen;
2079 u16 xpos=0,ypos=0,xsize=0,ysize=0;
2081 fbprintk("%s\n",__FUNCTION__);
2082 xpos = LcdRdReg(inf, WIN0_DSP_ST) & 0xffff;
2083 ypos = (LcdRdReg(inf, WIN0_DSP_ST)>>16) & 0xffff;
2085 xpos -= (screen->left_margin + screen->hsync_len);
2086 ypos -= (screen->upper_margin + screen->vsync_len);
2088 xsize=LcdRdReg(inf, WIN0_DSP_INFO)& 0xffff;
2089 ysize=(LcdRdReg(inf, WIN0_DSP_INFO)>>16) & 0xffff;
2090 fbprintk("%s %d , %d, %d ,%d\n",__FUNCTION__,xpos,ypos,xsize,ysize);
2091 rk29_set_cursor_test(inf->fb0);
2093 return snprintf(buf, PAGE_SIZE, "%d,%d,%d,%d\n", xpos,ypos,xsize,ysize);
2096 static ssize_t dsp_win0_info_write(struct device *device,
2097 struct device_attribute *attr, const char *buf, size_t count)
2099 printk("%s\n",__FUNCTION__);
2100 printk("%s %x \n",__FUNCTION__,*buf);
2104 static DEVICE_ATTR(dsp_win0_info, S_IRUGO|S_IWUSR, dsp_win0_info_read, dsp_win0_info_write);
2106 static irqreturn_t rk29fb_irq(int irq, void *dev_id)
2108 struct platform_device *pdev = (struct platform_device*)dev_id;
2109 struct rk29fb_inf *inf = platform_get_drvdata(pdev);
2110 struct win0_par *par = (struct win0_par *)inf->fb1->par;
2114 //fbprintk(">>>>>> %s : %s \n", __FILE__, __FUNCTION__);
2116 LcdMskReg(inf, INT_STATUS, m_FRM_STARTCLEAR, v_FRM_STARTCLEAR(1));
2118 if(SCREEN_MCU == inf->cur_screen->type)
2120 inf->mcu_isrcnt = !inf->mcu_isrcnt;
2126 if(LcdReadBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST) && (inf->mcu_fmksync == 0))
2128 inf->mcu_fmksync = 1;
2129 if(inf->cur_screen->refresh)
2130 inf->cur_screen->refresh(REFRESH_END);
2131 inf->mcu_fmksync = 0;
2140 if(inf->mcu_needflush) {
2141 if(inf->cur_screen->refresh)
2142 inf->cur_screen->refresh(REFRESH_PRE);
2143 inf->mcu_needflush = 0;
2144 inf->mcu_isrcnt = 0;
2145 LcdSetRegBit(inf, MCU_TIMING_CTRL, m_MCU_HOLDMODE_FRAME_ST);
2147 if(inf->cur_screen->refresh)
2148 inf->cur_screen->refresh(REFRESH_END);
2152 #if ANDROID_USE_THREE_BUFS
2153 new_frame_seted = 1;
2156 if(waitqueue_active(&par->wait)) {
2157 if (par->mirror.c_offset == 0)
2158 printk("error: no new buffer to display\n");
2160 par->done.y_offset = par->displ.y_offset;
2161 par->done.c_offset = par->displ.c_offset;
2162 par->displ.y_offset = par->mirror.y_offset;
2163 par->displ.c_offset = par->mirror.c_offset;
2164 par->mirror.y_offset = 0;
2165 par->mirror.c_offset = 0;
2167 //printk("0x%.8x 0x%.8x displaying\n", par->displ.y_offset, par->displ.c_offset);
2168 //printk("0x%.8x 0x%.8x done\n", par->done.y_offset, par->done.c_offset);
2169 wake_up_interruptible(&par->wait);
2174 wake_up_interruptible(&wq);
2179 #ifdef CONFIG_HAS_EARLYSUSPEND
2181 struct suspend_info {
2182 struct early_suspend early_suspend;
2183 struct rk29fb_inf *inf;
2186 static void rk29fb_early_suspend(struct early_suspend *h)
2188 struct suspend_info *info = container_of(h, struct suspend_info,
2191 struct rk29fb_inf *inf = info->inf;
2193 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
2196 printk("inf==0, rk29fb_suspend fail! \n");
2200 set_lcd_pin(g_pdev, 0);
2202 if(inf->cur_screen->standby)
2204 fbprintk(">>>>>> power down the screen! \n");
2205 inf->cur_screen->standby(1);
2208 LcdMskReg(inf, DSP_CTRL0, m_HSYNC_POLARITY | m_VSYNC_POLARITY | m_DEN_POLARITY ,
2209 v_HSYNC_POLARITY(1) | v_VSYNC_POLARITY(1) | v_DEN_POLARITY(1) );
2211 LcdMskReg(inf, DSP_CTRL1, m_BLANK_MODE , v_BLANK_MODE(1));
2212 LcdMskReg(inf, SYS_CONFIG, m_STANDBY, v_STANDBY(1));
2213 LcdWrReg(inf, REG_CFG_DONE, 0x01);
2215 if(!inf->in_suspend)
2217 fbprintk(">>>>>> diable the lcdc clk! \n");
2218 wake_lock(&idlelock);
2220 wake_unlock(&idlelock);
2221 clk_disable(inf->aclk_ddr_lcdc);
2222 clk_disable(inf->aclk_disp_matrix);
2223 clk_disable(inf->hclk_cpu_display);
2224 clk_disable(inf->clk);
2226 clk_disable(inf->dclk);
2229 clk_disable(inf->aclk);
2231 clk_disable(inf->pd_display);
2233 inf->in_suspend = 1;
2237 static void rk29fb_early_resume(struct early_suspend *h)
2239 struct suspend_info *info = container_of(h, struct suspend_info,
2242 struct rk29fb_inf *inf = info->inf;
2243 struct rk29fb_screen *screen = inf->cur_screen;
2245 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
2247 printk("inf==0, rk29fb_resume fail! \n");
2253 inf->in_suspend = 0;
2254 fbprintk(">>>>>> enable the lcdc clk! \n");
2255 clk_enable(inf->pd_display);
2256 clk_enable(inf->aclk_disp_matrix);
2257 clk_enable(inf->hclk_cpu_display);
2258 clk_enable(inf->clk);
2259 clk_enable(inf->aclk_ddr_lcdc);
2262 clk_enable(inf->dclk);
2265 clk_enable(inf->aclk);
2269 LcdMskReg(inf, DSP_CTRL1, m_BLANK_MODE , v_BLANK_MODE(0));
2270 LcdMskReg(inf, SYS_CONFIG, m_STANDBY, v_STANDBY(0));
2271 LcdWrReg(inf, REG_CFG_DONE, 0x01);
2273 LcdMskReg(inf, DSP_CTRL0, m_HSYNC_POLARITY | m_VSYNC_POLARITY | m_DEN_POLARITY ,
2274 v_HSYNC_POLARITY(screen->pin_hsync) | v_VSYNC_POLARITY(screen->pin_vsync) | v_DEN_POLARITY(screen->pin_den) );
2276 if(inf->cur_screen->standby)
2278 fbprintk(">>>>>> power on the screen! \n");
2279 inf->cur_screen->standby(0);
2282 set_lcd_pin(g_pdev, 1);
2283 memcpy((u8*)inf->preg, (u8*)&inf->regbak, 0xa4); //resume reg
2286 static struct suspend_info suspend_info = {
2287 .early_suspend.suspend = rk29fb_early_suspend,
2288 .early_suspend.resume = rk29fb_early_resume,
2289 .early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB,
2293 static int __init rk29fb_probe (struct platform_device *pdev)
2295 struct rk29fb_inf *inf = NULL;
2296 struct resource *res = NULL;
2297 struct resource *mem = NULL;
2298 struct rk29fb_info *mach_info = NULL;
2299 struct rk29fb_screen *screen = NULL;
2300 struct win0_par* par = NULL;
2304 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
2306 /* Malloc rk29fb_inf and set it to pdev for drvdata */
2307 fbprintk(">> Malloc rk29fb_inf and set it to pdev for drvdata \n");
2308 inf = kmalloc(sizeof(struct rk29fb_inf), GFP_KERNEL);
2311 dev_err(&pdev->dev, ">> inf kmalloc fail!");
2313 goto release_drvdata;
2315 memset(inf, 0, sizeof(struct rk29fb_inf));
2316 platform_set_drvdata(pdev, inf);
2318 mach_info = pdev->dev.platform_data;
2319 /* Fill screen info and set current screen */
2320 fbprintk(">> Fill screen info and set current screen \n");
2321 #ifdef CONFIG_DEFAULT_OUT_HDMI // set hdmi for default output
2322 hdmi_get_default_resolution(&inf->panel1_info);
2324 set_lcd_info(&inf->panel1_info, mach_info->lcd_info);
2326 inf->cur_screen = &inf->panel1_info;
2327 screen = inf->cur_screen;
2328 if(SCREEN_NULL==screen->type)
2330 dev_err(&pdev->dev, ">> Please select a display device! \n");
2332 goto release_drvdata;
2335 /* get virtual basic address of lcdc register */
2336 fbprintk(">> get virtual basic address of lcdc register \n");
2337 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lcdc reg");
2340 dev_err(&pdev->dev, "failed to get memory registers\n");
2342 goto release_drvdata;
2344 inf->reg_phy_base = res->start;
2345 inf->len = (res->end - res->start) + 1;
2346 mem = request_mem_region(inf->reg_phy_base, inf->len, pdev->name);
2349 dev_err(&pdev->dev, "failed to get memory region\n");
2351 goto release_drvdata;
2353 fbprintk("inf->reg_phy_base = 0x%08x, inf->len = %d \n", inf->reg_phy_base, inf->len);
2354 inf->reg_vir_base = ioremap(inf->reg_phy_base, inf->len);
2355 if (inf->reg_vir_base == NULL)
2357 dev_err(&pdev->dev, "ioremap() of registers failed\n");
2359 goto release_drvdata;
2361 inf->preg = (LCDC_REG*)inf->reg_vir_base;
2363 /* Prepare win1 info */
2364 fbprintk(">> Prepare win1 info \n");
2365 inf->fb0 = framebuffer_alloc(sizeof(struct win0_par), &pdev->dev);
2368 dev_err(&pdev->dev, ">> fb0 framebuffer_alloc fail!");
2371 goto release_win1fb;
2374 par = (struct win0_par*)inf->fb0->par;
2375 strcpy(inf->fb0->fix.id, "fb0");
2376 inf->fb0->fix.type = FB_TYPE_PACKED_PIXELS;
2377 inf->fb0->fix.type_aux = 0;
2378 inf->fb0->fix.xpanstep = 1;
2379 inf->fb0->fix.ypanstep = 1;
2380 inf->fb0->fix.ywrapstep = 0;
2381 inf->fb0->fix.accel = FB_ACCEL_NONE;
2382 inf->fb0->fix.visual = FB_VISUAL_TRUECOLOR;
2383 inf->fb0->fix.smem_len = 0;
2384 inf->fb0->fix.line_length = 0;
2385 inf->fb0->fix.smem_start = 0;
2387 inf->fb0->var.xres = screen->x_res;
2388 inf->fb0->var.yres = screen->y_res;
2389 inf->fb0->var.bits_per_pixel = 16;
2390 inf->fb0_color_deepth = 0;
2391 inf->fb0->var.xres_virtual = screen->x_res;
2392 inf->fb0->var.yres_virtual = screen->y_res;
2393 inf->fb0->var.width = screen->width;
2394 inf->fb0->var.height = screen->height;
2395 inf->fb0->var.pixclock = screen->pixclock;
2396 inf->fb0->var.left_margin = screen->left_margin;
2397 inf->fb0->var.right_margin = screen->right_margin;
2398 inf->fb0->var.upper_margin = screen->upper_margin;
2399 inf->fb0->var.lower_margin = screen->lower_margin;
2400 inf->fb0->var.vsync_len = screen->vsync_len;
2401 inf->fb0->var.hsync_len = screen->hsync_len;
2402 inf->fb0->var.red = def_rgb_16.red;
2403 inf->fb0->var.green = def_rgb_16.green;
2404 inf->fb0->var.blue = def_rgb_16.blue;
2405 inf->fb0->var.transp = def_rgb_16.transp;
2407 inf->fb0->var.nonstd = 0; //win1 format & ypos & xpos (ypos<<20 + xpos<<8 + format)
2408 inf->fb0->var.grayscale = 0; //win1 transprent mode & value(mode<<8 + value)
2409 inf->fb0->var.activate = FB_ACTIVATE_NOW;
2410 inf->fb0->var.accel_flags = 0;
2411 inf->fb0->var.vmode = FB_VMODE_NONINTERLACED;
2413 inf->fb0->fbops = &fb0_ops;
2414 inf->fb0->flags = FBINFO_FLAG_DEFAULT;
2415 inf->fb0->pseudo_palette = par->pseudo_pal;
2416 inf->fb0->screen_base = 0;
2418 memset(par, 0, sizeof(struct win0_par));
2420 ret = fb_alloc_cmap(&inf->fb0->cmap, 256, 0);
2424 /* alloc win1 buf */
2425 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "win1 buf");
2428 dev_err(&pdev->dev, "failed to get win1 memory \n");
2430 goto release_win1fb;
2432 inf->fb0->fix.smem_start = res->start;
2433 inf->fb0->fix.smem_len = res->end - res->start + 1;
2434 inf->fb0->screen_base = ioremap(res->start, inf->fb0->fix.smem_len);
2435 memset(inf->fb0->screen_base, 0, inf->fb0->fix.smem_len);
2437 #ifdef CONFIG_FB_WORK_IPP
2438 /* alloc win1 ipp buf */
2439 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "win1 ipp buf");
2442 dev_err(&pdev->dev, "failed to get win1 ipp memory \n");
2444 goto release_win1fb;
2446 inf->fb0->fix.mmio_start = res->start;
2447 inf->fb0->fix.mmio_len = res->end - res->start + 1;
2450 /* Prepare win0 info */
2451 fbprintk(">> Prepare win0 info \n");
2452 inf->fb1 = framebuffer_alloc(sizeof(struct win0_par), &pdev->dev);
2455 dev_err(&pdev->dev, ">> fb1 framebuffer_alloc fail!");
2458 goto release_win0fb;
2461 par = (struct win0_par*)inf->fb1->par;
2463 strcpy(inf->fb1->fix.id, "fb1");
2464 inf->fb1->fix.type = FB_TYPE_PACKED_PIXELS;
2465 inf->fb1->fix.type_aux = 0;
2466 inf->fb1->fix.xpanstep = 1;
2467 inf->fb1->fix.ypanstep = 1;
2468 inf->fb1->fix.ywrapstep = 0;
2469 inf->fb1->fix.accel = FB_ACCEL_NONE;
2470 inf->fb1->fix.visual = FB_VISUAL_TRUECOLOR;
2471 inf->fb1->fix.smem_len = 0;
2472 inf->fb1->fix.line_length = 0;
2473 inf->fb1->fix.smem_start = 0;
2475 inf->fb1->var.xres = screen->x_res;
2476 inf->fb1->var.yres = screen->y_res;
2477 inf->fb1->var.bits_per_pixel = 16;
2478 inf->fb1->var.xres_virtual = screen->x_res;
2479 inf->fb1->var.yres_virtual = screen->y_res;
2480 inf->fb1->var.width = screen->width;
2481 inf->fb1->var.height = screen->height;
2482 inf->fb1->var.pixclock = screen->pixclock;
2483 inf->fb1->var.left_margin = screen->left_margin;
2484 inf->fb1->var.right_margin = screen->right_margin;
2485 inf->fb1->var.upper_margin = screen->upper_margin;
2486 inf->fb1->var.lower_margin = screen->lower_margin;
2487 inf->fb1->var.vsync_len = screen->vsync_len;
2488 inf->fb1->var.hsync_len = screen->hsync_len;
2489 inf->fb1->var.red = def_rgb_16.red;
2490 inf->fb1->var.green = def_rgb_16.green;
2491 inf->fb1->var.blue = def_rgb_16.blue;
2492 inf->fb1->var.transp = def_rgb_16.transp;
2494 inf->fb1->var.nonstd = 0; //win0 format & ypos & xpos (ypos<<20 + xpos<<8 + format)
2495 inf->fb1->var.grayscale = ((inf->fb1->var.yres<<20)&0xfff00000) + ((inf->fb1->var.xres<<8)&0xfff00);//win0 xsize & ysize
2496 inf->fb1->var.activate = FB_ACTIVATE_NOW;
2497 inf->fb1->var.accel_flags = 0;
2498 inf->fb1->var.vmode = FB_VMODE_NONINTERLACED;
2500 inf->fb1->fbops = &fb1_ops;
2501 inf->fb1->flags = FBINFO_FLAG_DEFAULT;
2502 inf->fb1->pseudo_palette = par->pseudo_pal;
2503 inf->fb1->screen_base = 0;
2505 memset(par, 0, sizeof(struct win0_par));
2507 init_waitqueue_head(&par->wait);
2509 /* Init all lcdc and lcd before register_framebuffer. */
2510 /* because after register_framebuffer, the win1fb_check_par and winfb_set_par execute immediately */
2511 fbprintk(">> Init all lcdc and lcd before register_framebuffer \n");
2512 init_lcdc(inf->fb0);
2514 #if 0 //def CONFIG_CPU_FREQ
2515 // inf->freq_transition.notifier_call = rk29fb_freq_transition;
2516 // cpufreq_register_notifier(&inf->freq_transition, CPUFREQ_TRANSITION_NOTIFIER);
2518 fbprintk("got clock\n");
2522 struct rk29_fb_setting_info fb_setting;
2523 if( OUT_P888==inf->cur_screen->face ) // set lcdc iomux
2525 fb_setting.data_num = 24;
2527 else if(OUT_P666 == inf->cur_screen->face )
2529 fb_setting.data_num = 18;
2533 fb_setting.data_num = 16;
2535 fb_setting.den_en = 1;
2536 fb_setting.vsync_en = 1;
2537 fb_setting.disp_on_en = 1;
2538 fb_setting.standby_en = 1;
2539 if( inf->cur_screen->mcu_usefmk )
2540 fb_setting.mcu_fmk_en =1;
2541 mach_info->io_init(&fb_setting);
2544 set_lcd_pin(pdev, 1);
2547 inf->mcu_usetimer = 1;
2548 inf->mcu_fmksync = 0;
2549 load_screen(inf->fb0, 1);
2551 /* Register framebuffer(fb0 & fb1) */
2552 fbprintk(">> Register framebuffer(fb0) \n");
2553 ret = register_framebuffer(inf->fb0);
2556 printk(">> fb0 register_framebuffer fail!\n");
2558 goto release_win0fb;
2560 fbprintk(">> Register framebuffer(fb1) \n");
2562 ret = register_framebuffer(inf->fb1);
2565 printk(">> fb1 register_framebuffer fail!\n");
2567 goto unregister_win1fb;
2570 ret = device_create_file(inf->fb1->dev, &dev_attr_dsp_win0_info);
2573 printk(">> fb1 dsp win0 info device_create_file err\n");
2576 #ifdef CONFIG_HAS_EARLYSUSPEND
2577 suspend_info.inf = inf;
2578 register_early_suspend(&suspend_info.early_suspend);
2581 /* get and request irq */
2582 fbprintk(">> get and request irq \n");
2583 irq = platform_get_irq(pdev, 0);
2585 dev_err(&pdev->dev, "no irq for device\n");
2587 goto unregister_win1fb;
2589 ret = request_irq(irq, rk29fb_irq, IRQF_DISABLED, pdev->name, pdev);
2591 dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
2596 if( inf->cur_screen->mcu_usefmk && (mach_info->mcu_fmk_pin != -1) )
2598 ret = request_irq(gpio_to_irq(mach_info->mcu_fmk_pin), mcu_irqfmk, GPIOEdgelFalling, pdev->name, pdev);
2601 dev_err(&pdev->dev, "cannot get fmk irq %d - err %d\n", irq, ret);
2607 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
2608 fb0_set_par(inf->fb0);
2609 if (fb_prepare_logo(inf->fb0, FB_ROTATE_UR)) {
2610 /* Start display and show logo on boot */
2611 fb_set_cmap(&inf->fb0->cmap, inf->fb0);
2612 fb_show_logo(inf->fb0, FB_ROTATE_UR);
2613 fb0_blank(FB_BLANK_UNBLANK, inf->fb0);
2617 printk(" %s ok\n", __FUNCTION__);
2622 free_irq(irq, pdev);
2624 unregister_framebuffer(inf->fb0);
2627 framebuffer_release(inf->fb1);
2631 fb_dealloc_cmap(&inf->fb0->cmap);
2634 framebuffer_release(inf->fb0);
2637 if(inf && inf->reg_vir_base)
2638 iounmap(inf->reg_vir_base);
2640 release_mem_region(inf->reg_phy_base, inf->len);
2643 platform_set_drvdata(pdev, NULL);
2647 static int rk29fb_remove(struct platform_device *pdev)
2649 struct rk29fb_inf *inf = platform_get_drvdata(pdev);
2650 struct fb_info *info = NULL;
2652 struct rk29fb_info *mach_info = NULL;
2655 fbprintk(">>>>>> %s : %s\n", __FILE__, __FUNCTION__);
2658 printk("inf==0, rk29_fb_remove fail! \n");
2661 device_remove_file(inf->fb1->dev, &dev_attr_dsp_win0_info);
2663 irq = platform_get_irq(pdev, 0);
2666 free_irq(irq, pdev);
2669 mach_info = pdev->dev.platform_data;
2670 if(mach_info->mcu_fmk_pin)
2672 free_irq(gpio_to_irq(mach_info->mcu_fmk_pin), pdev);
2675 set_lcd_pin(pdev, 0);
2679 fb1_blank(FB_BLANK_POWERDOWN, inf->fb1);
2681 fb0_blank(FB_BLANK_POWERDOWN, inf->fb0);
2684 //rk29fb_suspend(pdev, msg);
2685 // unmap memory and release framebuffer
2688 if (info->screen_base) {
2689 //dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len),info->screen_base, info->fix.smem_start);
2690 info->screen_base = 0;
2691 info->fix.smem_start = 0;
2692 info->fix.smem_len = 0;
2694 unregister_framebuffer(inf->fb1);
2695 framebuffer_release(inf->fb1);
2700 if (info->screen_base) {
2701 // dma_free_writecombine(NULL, PAGE_ALIGN(info->fix.smem_len),info->screen_base, info->fix.smem_start);
2702 info->screen_base = 0;
2703 info->fix.smem_start = 0;
2704 info->fix.smem_len = 0;
2706 unregister_framebuffer(inf->fb0);
2707 framebuffer_release(inf->fb0);
2711 #if 0 //def CONFIG_CPU_FREQ
2712 // cpufreq_unregister_notifier(&inf->freq_transition, CPUFREQ_TRANSITION_NOTIFIER);
2719 clk_disable(inf->clk);
2725 clk_disable(inf->dclk);
2731 platform_set_drvdata(pdev, NULL);
2736 static void rk29fb_shutdown(struct platform_device *pdev)
2738 struct rk29fb_inf *inf = platform_get_drvdata(pdev);
2740 fbprintk("----------------------------rk29fb_shutdown----------------------------\n");
2742 set_lcd_pin(pdev, 0);
2743 if(!inf->in_suspend)
2745 LcdMskReg(inf, DSP_CTRL1, m_BLANK_MODE , v_BLANK_MODE(1));
2746 LcdMskReg(inf, SYS_CONFIG, m_STANDBY, v_STANDBY(1));
2747 LcdWrReg(inf, REG_CFG_DONE, 0x01);
2749 clk_disable(inf->aclk_ddr_lcdc);
2750 clk_disable(inf->aclk_disp_matrix);
2751 clk_disable(inf->hclk_cpu_display);
2752 clk_disable(inf->clk);
2754 clk_disable(inf->dclk);
2757 clk_disable(inf->aclk);
2759 clk_disable(inf->pd_display);
2760 //pmu_set_power_domain(PD_DISPLAY, 0);
2761 inf->in_suspend = 1;
2766 static struct platform_driver rk29fb_driver = {
2767 .probe = rk29fb_probe,
2768 .remove = rk29fb_remove,
2771 .owner = THIS_MODULE,
2773 .shutdown = rk29fb_shutdown,
2776 static int __init rk29fb_init(void)
2778 wake_lock_init(&idlelock, WAKE_LOCK_IDLE, "fb");
2779 return platform_driver_register(&rk29fb_driver);
2782 static void __exit rk29fb_exit(void)
2784 platform_driver_unregister(&rk29fb_driver);
2787 fs_initcall(rk29fb_init);
2788 module_exit(rk29fb_exit);
2791 MODULE_AUTHOR(" zyw@rock-chips.com");
2792 MODULE_DESCRIPTION("Driver for rk29 fb device");
2793 MODULE_LICENSE("GPL");