diff --git a/drivers/usb/dwc_otg/dwc_otg_cil_intr.c b/drivers/usb/dwc_otg/dwc_otg_cil_intr.c
index bb3a89600371..a4a07b42b27a 100755
--- a/drivers/usb/dwc_otg/dwc_otg_cil_intr.c
+++ b/drivers/usb/dwc_otg/dwc_otg_cil_intr.c
@@ -340,7 +340,7 @@ int32_t dwc_otg_handle_otg_intr(dwc_otg_core_if_t *_core_if)
 #ifdef DWC_BOTH_HOST_SLAVE
 extern void dwc_otg_force_device(dwc_otg_core_if_t *core_if);
 extern void dwc_otg_force_host(dwc_otg_core_if_t *core_if);
-extern int rk28_usb_suspend( int exitsuspend );
+extern int dwc_otg20phy_suspend( int exitsuspend );
 #endif
 
 int32_t dwc_otg_handle_conn_id_status_change_intr(dwc_otg_core_if_t *_core_if)
@@ -353,7 +353,7 @@ int32_t dwc_otg_handle_conn_id_status_change_intr(dwc_otg_core_if_t *_core_if)
     gotgctl_data_t gotgctl = { .d32 = 0 }; 
 	if(pcd &&(pcd->phy_suspend == 1))
 	{
-		rk28_usb_suspend( 1 );
+		dwc_otg20phy_suspend( 1 );
 	}
 	
     /*
diff --git a/drivers/usb/dwc_otg/dwc_otg_driver.c b/drivers/usb/dwc_otg/dwc_otg_driver.c
index 54b295f3a9af..403def8a463b 100755
--- a/drivers/usb/dwc_otg/dwc_otg_driver.c
+++ b/drivers/usb/dwc_otg/dwc_otg_driver.c
@@ -68,9 +68,7 @@
 #include "dwc_otg_cil.h"
 #include "dwc_otg_pcd.h"
 #include "dwc_otg_hcd.h"
-#ifdef CONFIG_ARCH_RK29
 #include <mach/cru.h>
-#endif
 //#define DWC_DRIVER_VERSION	"2.60a 22-NOV-2006"
 //#define DWC_DRIVER_VERSION	"2.70 2009-12-31"
 #define DWC_DRIVER_VERSION	"3.00 2010-12-12 rockchip"
@@ -338,7 +336,7 @@ extern struct usb_hub *g_root_hub20;
 #ifdef DWC_BOTH_HOST_SLAVE
 extern void hcd_start( dwc_otg_core_if_t *_core_if );
 
-extern int rk28_usb_suspend( int exitsuspend );
+extern int dwc_otg20phy_suspend( int exitsuspend );
 extern void hub_disconnect_device(struct usb_hub *hub);
 
 static ssize_t force_usb_mode_show(struct device_driver *_drv, char *_buf)
@@ -376,7 +374,7 @@ void dwc_otg_force_host(dwc_otg_core_if_t *core_if)
     }
 	if((otg_dev->pcd)&&(otg_dev->pcd->phy_suspend == 1))
 	{
-		rk28_usb_suspend( 1 );
+		dwc_otg20phy_suspend( 1 );
 	}
     del_timer(&otg_dev->pcd->check_vbus_timer);
     // force disconnect 
@@ -503,7 +501,7 @@ static ssize_t force_usb_mode_store(struct device_driver *_drv, const char *_buf
 				core_if->usb_mode = new_mode;
 				if((otg_dev->pcd)&&(otg_dev->pcd->phy_suspend == 1))
 				{
-					rk28_usb_suspend( 1 );
+					dwc_otg20phy_suspend( 1 );
 				}
 				del_timer(&otg_dev->pcd->check_vbus_timer);
 				dwc_otg_set_gusbcfg(core_if, new_mode);
@@ -525,7 +523,7 @@ static ssize_t force_usb_mode_store(struct device_driver *_drv, const char *_buf
 			{
 				if((otg_dev->pcd)&&(otg_dev->pcd->phy_suspend == 1))
 				{
-					rk28_usb_suspend( 1 );
+					dwc_otg20phy_suspend( 1 );
 				}
 				core_if->usb_mode = new_mode;
 				dwc_otg_set_gusbcfg(core_if, new_mode);
@@ -1152,8 +1150,10 @@ static int dwc_otg_driver_remove(struct platform_device *pdev)
 	clk_disable(otg_dev->phyclk);
 	clk_put(otg_dev->ahbclk);
 	clk_disable(otg_dev->ahbclk);
+#ifdef CONFIG_ARCH_RK29	
 	clk_put(otg_dev->busclk);
 	clk_disable(otg_dev->busclk);
+#endif
 	kfree(otg_dev);
 
 	/*
@@ -1195,11 +1195,11 @@ static __devinit int dwc_otg_driver_probe(struct platform_device *pdev)
     unsigned int * otg_phy_con1 = (unsigned int*)(USB_GRF_CON);
 #endif
 #ifdef CONFIG_ARCH_RK30
-    unsigned int * otg_phy_con1 = (unsigned int*)(USBGRF_UOC0_CON2);
+    unsigned int * otg_phy_con = (unsigned int*)(USBGRF_UOC0_CON2);
 #endif
     
-    regval = * otg_phy_con1;
-#ifdef CONFIG_ARCH_RK29    
+#ifdef CONFIG_ARCH_RK29   
+    regval = * otg_phy_con1; 
 #ifndef CONFIG_USB11_HOST
 	/*
 	 * disable usb host 1.1 controller if not support
@@ -1258,6 +1258,34 @@ static __devinit int dwc_otg_driver_probe(struct platform_device *pdev)
 #endif
 #endif
 
+#ifdef CONFIG_ARCH_RK30
+#ifndef CONFIG_USB20_HOST
+    otg_phy_con = (unsigned int*)(USBGRF_UOC1_CON2);
+    /*
+     * disable usb host 2.0 phy if not support
+     */
+    phyclk = clk_get(NULL, "otgphy1");
+    if (IS_ERR(phyclk)) {
+            retval = PTR_ERR(phyclk);
+            DWC_ERROR("can't get USBPHY1 clock\n");
+           goto fail;
+    }
+    clk_enable(phyclk);
+    
+    ahbclk = clk_get(NULL, "hclk_otg1");
+    if (IS_ERR(ahbclk)) {
+            retval = PTR_ERR(ahbclk);
+            DWC_ERROR("can't get USBOTG1 ahb bus clock\n");
+           goto fail;
+    }
+    clk_enable(ahbclk);
+    
+    *otg_phy_con = ((0x01<<2)|(0x00<<3)|(0x05<<6))|(((0x01<<2)|(0x01<<3)|(0x07<<6))<<16);   // enter suspend.
+    udelay(3);
+    clk_disable(phyclk);
+    clk_disable(ahbclk);
+#endif
+#endif
 	dwc_otg_device = kmalloc(sizeof(dwc_otg_device_t), GFP_KERNEL);
 	
 	if (dwc_otg_device == 0) 
@@ -1315,7 +1343,42 @@ static __devinit int dwc_otg_driver_probe(struct platform_device *pdev)
 	dwc_otg_device->phyclk = phyclk;
 	dwc_otg_device->ahbclk = ahbclk;
 	dwc_otg_device->busclk = busclk;
-#endif	
+#endif
+#ifdef CONFIG_ARCH_RK30
+    otg_phy_con = (unsigned int*)(USBGRF_UOC0_CON2);
+    cru_set_soft_reset(SOFT_RST_USBPHY0, true);
+	cru_set_soft_reset(SOFT_RST_OTGC0, true);
+	cru_set_soft_reset(SOFT_RST_USBOTG0, true);
+    udelay(1);
+	
+	cru_set_soft_reset(SOFT_RST_USBOTG0, false);
+	cru_set_soft_reset(SOFT_RST_OTGC0, false);
+	cru_set_soft_reset(SOFT_RST_USBPHY0, false);
+
+    phyclk = clk_get(NULL, "otgphy0");
+    if (IS_ERR(phyclk)) {
+            retval = PTR_ERR(phyclk);
+            DWC_ERROR("can't get USBPHY0 clock\n");
+           goto fail;
+    }
+    clk_enable(phyclk);
+    
+    ahbclk = clk_get(NULL, "hclk_otg0");
+    if (IS_ERR(ahbclk)) {
+            retval = PTR_ERR(ahbclk);
+            DWC_ERROR("can't get USB otg0 ahb bus clock\n");
+           goto fail;
+    }
+    clk_enable(ahbclk);
+    
+	/*
+	 * Enable usb phy 0
+	 */
+    *otg_phy_con = ((0x01<<2)<<16);
+    
+	dwc_otg_device->phyclk = phyclk;
+	dwc_otg_device->ahbclk = ahbclk;
+#endif
 	/*
 	 * Map the DWC_otg Core memory into virtual address space.
 	 */
@@ -1324,8 +1387,7 @@ static __devinit int dwc_otg_driver_probe(struct platform_device *pdev)
 	if (!res_base)
 		goto fail;
 
-	dwc_otg_device->base =
-		ioremap(res_base->start,USBOTG_SIZE);
+	dwc_otg_device->base =  ioremap(res_base->start,USBOTG_SIZE);
 	if (dwc_otg_device->base == NULL)
 	{
 		dev_err(dev, "ioremap() failed\n");
@@ -1498,7 +1560,7 @@ static __devinit int dwc_otg_driver_probe(struct platform_device *pdev)
 }
 
 #ifndef CONFIG_DWC_OTG_HOST_ONLY
-extern int rk28_usb_suspend( int exitsuspend );
+extern int dwc_otg20phy_suspend( int exitsuspend );
 static int dwc_otg_driver_suspend(struct platform_device *_dev , pm_message_t state )
 {
 	struct device *dev = &_dev->dev;
@@ -1512,7 +1574,7 @@ static int dwc_otg_driver_suspend(struct platform_device *_dev , pm_message_t st
     /* Clear any pending interrupts */
     dwc_write_reg32( &core_if->core_global_regs->gintsts, 0xFFFFFFFF);
     dwc_otg_disable_global_interrupts(core_if);
-    rk28_usb_suspend(0);
+    dwc_otg20phy_suspend(0);
     del_timer(&otg_dev->pcd->check_vbus_timer); 
 	
     return 0;
@@ -1540,7 +1602,7 @@ static int dwc_otg_driver_resume(struct platform_device *_dev )
     }
 #ifndef CONFIG_DWC_OTG_HOST_ONLY
 
-    rk28_usb_suspend(1);
+    dwc_otg20phy_suspend(1);
 
     /* soft disconnect */
     /* 20100226,HSL@RK,if not disconnect,when usb cable in,will auto reconnect 
diff --git a/drivers/usb/dwc_otg/dwc_otg_pcd.c b/drivers/usb/dwc_otg/dwc_otg_pcd.c
index a1ad5d466ce9..8ea6354e68ed 100755
--- a/drivers/usb/dwc_otg/dwc_otg_pcd.c
+++ b/drivers/usb/dwc_otg/dwc_otg_pcd.c
@@ -1603,15 +1603,11 @@ int dwc_pcd_reset(dwc_otg_pcd_t *pcd)
  * 20090925,add vbus test code.500ms 间隔.
  * 20100122,HSL@RK,hard reset usb controller and phy.
 */
-int rk28_usb_suspend( int exitsuspend )
+int dwc_otg20phy_suspend( int exitsuspend )
 {
 	dwc_otg_pcd_t *pcd = s_pcd;
 #ifdef CONFIG_ARCH_RK29
     unsigned int * otg_phy_con1 = (unsigned int*)(USB_GRF_CON);
-#endif
-#ifdef CONFIG_ARCH_RK30
-    unsigned int * otg_phy_con1 = (unsigned int*)(USBGRF_UOC0_CON2);
-#endif
     if(exitsuspend && (pcd->phy_suspend == 1)) {
         clk_enable(pcd->otg_dev->ahbclk);
         clk_enable(pcd->otg_dev->phyclk);
@@ -1635,23 +1631,35 @@ int rk28_usb_suspend( int exitsuspend )
         //debug_print("disable usb phy\n");
         DWC_DEBUGPL(DBG_PCDV, "disable usb phy\n");
     }
+#endif
+#ifdef CONFIG_ARCH_RK30
+    unsigned int * otg_phy_con1 = (unsigned int*)(USBGRF_UOC0_CON2);
+    if(exitsuspend && (pcd->phy_suspend == 1)) {
+        clk_enable(pcd->otg_dev->ahbclk);
+        clk_enable(pcd->otg_dev->phyclk);
+        pcd->phy_suspend = 0;
+        *otg_phy_con1 = ((0x01<<2)<<16);    // exit suspend.
+//        *otg_phy_con1 |= (0x01<<3);
+//        *otg_phy_con1 &= ~(0x01<<2);
+        
+        /* 20091011,reenable usb phy ,will raise reset intr */
+//        DWC_PRINT("enable usb phy 0x%x\n", *otg_phy_con1);
+        DWC_DEBUGPL(DBG_PCDV, "enable usb phy\n");
+    }
+    if( !exitsuspend && (pcd->phy_suspend == 0)) {
+        pcd->phy_suspend = 1;
+        *otg_phy_con1 = ((0x01<<2)|(0x00<<3)|(0x05<<6))|(((0x01<<2)|(0x01<<3)|(0x07<<6))<<16);   // enter suspend.
+        udelay(3);
+        clk_disable(pcd->otg_dev->phyclk);
+        clk_disable(pcd->otg_dev->ahbclk);
+        //*otg_phy_con1 &= ~(0x01<<2);
+//        DWC_PRINT("disable usb phy 0x%x\n", *otg_phy_con1);
+        DWC_DEBUGPL(DBG_PCDV, "disable usb phy\n");
+    }
+#endif
     
     return pcd->phy_suspend;
 }
-void rk28_usb_force_resume( void )
-{
-	dwc_otg_pcd_t *pcd = s_pcd;
-    if( pcd ) {
-        del_timer(&pcd->check_vbus_timer); 
-    }
-    mdelay( 10 );
-    if( pcd ) {
-        pcd->phy_suspend = 1;
-        pcd->vbus_status = 0;
-    	dwc_otg_pcd_start_vbus_timer(pcd);
-    }
-}
-
 
 int dwc_otg_reset( void ) 
 {
@@ -1779,10 +1787,10 @@ static void dwc_otg_pcd_check_vbus_timer( unsigned long pdata )
         /* every 500 ms open usb phy power and start 1 jiffies timer to get vbus */
         if( _pcd->phy_suspend == 0 ) {
                 /* no vbus detect here , close usb phy for 500ms */
-             rk28_usb_suspend( 0 );
+             dwc_otg20phy_suspend( 0 );
               _pcd->check_vbus_timer.expires = jiffies + (HZ/2); /* 500 ms */
         } else if( _pcd->phy_suspend  == 1 ) { 
-             rk28_usb_suspend( 1 );
+             dwc_otg20phy_suspend( 1 );
              /*20100325 yk@rk,delay 2-->8,for host connect id detect*/
              _pcd->check_vbus_timer.expires = jiffies + 8; /* 20091127,HSL@RK,1-->2  */
              
@@ -1802,6 +1810,7 @@ static void dwc_otg_pcd_check_vbus_timer( unsigned long pdata )
     dctl_data_t dctl = {.d32=0};
     //dsts_data_t           gsts;
 	unsigned long flags;
+	local_irq_save(flags);
 #ifdef CONFIG_ARCH_RK30
     unsigned int usbgrf_status = *(unsigned int*)(USBGRF_SOC_STATUS0);
 #endif
@@ -1809,44 +1818,17 @@ static void dwc_otg_pcd_check_vbus_timer( unsigned long pdata )
 	if(usbgrf_status &0x20000){  // bvalid
         /* if usb not connect before ,then start connect */
          if( _pcd->vbus_status == 0 ) {
-            dwc_otg_msc_lock(_pcd);
             DWC_PRINT("********vbus detect*********************************************\n");
+            dwc_otg_msc_lock(_pcd);
     	    _pcd->vbus_status = 1;
             if(_pcd->conn_en)
-    	    {
-        	    if( _pcd->phy_suspend  == 1 ) { 
-//                     rk28_usb_suspend( 1 );
-                }
-        	    schedule_delayed_work( &_pcd->reconnect , 8 ); /* delay 1 jiffies */
-    		     _pcd->check_vbus_timer.expires = jiffies + (HZ<<1); /* 1 s */
-    	    }
-
-        } else if((_pcd->conn_status>0)&&(_pcd->conn_status <3)) {
-            //dwc_otg_msc_unlock(_pcd);
+                goto connect;
+        } 
+        else if((_pcd->conn_en)&&(_pcd->conn_status>=0)&&(_pcd->conn_status <3)){
             DWC_PRINT("********soft reconnect******************************************\n");
-            //_pcd->vbus_status =0;
-            
-            /* soft disconnect */
-	        dctl.d32 = dwc_read_reg32( &core_if->dev_if->dev_global_regs->dctl );
-	        dctl.b.sftdiscon = 1;
-	        dwc_write_reg32( &core_if->dev_if->dev_global_regs->dctl, dctl.d32 );
-            /* Clear any pending interrupts */
-            dwc_write_reg32( &core_if->core_global_regs->gintsts, 0xFFFFFFFF); 
-            if(_pcd->conn_en)
-    	    {
-        	    schedule_delayed_work( &_pcd->reconnect , 8 ); /* delay 1 jiffies */
-    		     _pcd->check_vbus_timer.expires = jiffies + (HZ<<1); /* 1 s */
-    	    }
+    	    goto connect;
         }
-        else if((_pcd->conn_en)&&(_pcd->conn_status == 0))
-        {
-            DWC_PRINT("********vbus detect ccccc*********************************************\n");
-    	
-    	    schedule_delayed_work( &_pcd->reconnect , 8 ); /* delay 1 jiffies */
-		     _pcd->check_vbus_timer.expires = jiffies + (HZ<<1); /* 1 s */
-        }
-        else if(_pcd->conn_status ==3)
-        {
+        else if(_pcd->conn_status ==3){
 			//*连接不上时释放锁，允许系统进入二级睡眠，yk@rk,20100331*//
             dwc_otg_msc_unlock(_pcd);
             _pcd->conn_status++;
@@ -1863,9 +1845,20 @@ static void dwc_otg_pcd_check_vbus_timer( unsigned long pdata )
         /* every 500 ms open usb phy power and start 1 jiffies timer to get vbus */
         if( _pcd->phy_suspend == 0 ) 
                 /* no vbus detect here , close usb phy  */
-             rk28_usb_suspend( 0 );
+             dwc_otg20phy_suspend( 0 );
     }
     add_timer(&_pcd->check_vbus_timer); 
+	local_irq_restore(flags);
+    return;
+
+connect:
+    if( _pcd->phy_suspend  == 1 )
+         dwc_otg20phy_suspend( 1 );
+    schedule_delayed_work( &_pcd->reconnect , 8 ); /* delay 1 jiffies */
+     _pcd->check_vbus_timer.expires = jiffies + (HZ<<1); /* 1 s */
+    add_timer(&_pcd->check_vbus_timer); 
+	local_irq_restore(flags);
+    return;
 }
 
 #endif
diff --git a/drivers/video/rockchip/rga/rga.h b/drivers/video/rockchip/rga/rga.h
index eb1d93408869..19807abce3bc 100755
--- a/drivers/video/rockchip/rga/rga.h
+++ b/drivers/video/rockchip/rga/rga.h
@@ -372,7 +372,8 @@ typedef struct rga_service_info {
     uint32_t            *pre_scale_buf;
     atomic_t            int_disable;     /* 0 int enable 1 int disable  */
     atomic_t            cmd_num;
-    //uint32_t            mmu_buf[4];
+    atomic_t            src_format_swt;
+    int                 last_prc_src_format;
     bool			    enabled;
 } rga_service_info;
 
diff --git a/drivers/video/rockchip/rga/rga_drv.c b/drivers/video/rockchip/rga/rga_drv.c
index 0e413e477c21..cdf4c3480867 100755
--- a/drivers/video/rockchip/rga/rga_drv.c
+++ b/drivers/video/rockchip/rga/rga_drv.c
@@ -52,6 +52,8 @@
 
 #define RGA_TEST 0
 #define RGA_TEST_TIME 0
+#define RGA_TEST_FLUSH_TIME 0
+
 
 #define PRE_SCALE_BUF_SIZE  2048*1024*4
 
@@ -207,7 +209,7 @@ static void rga_dump(void)
 static void rga_power_on(void)
 {
 	//printk("rga_power_on\n");
-	cancel_delayed_work_sync(&drvdata->power_off_work);
+	//cancel_delayed_work_sync(&drvdata->power_off_work);
 	if (drvdata->enable)
 		return;
    
@@ -218,7 +220,7 @@ static void rga_power_on(void)
 }
 
 
-static void rga_power_off(struct work_struct *work)
+static void rga_power_off(void)
 {
     int total_running;
     
@@ -245,16 +247,31 @@ static int rga_flush(rga_session *session, unsigned long arg)
 {
 	//printk("rga_get_result %d\n",drvdata->rga_result);
 	
-    int ret;
+    int ret = 0;
+    int ret_timeout;
 
-    ret = wait_event_interruptible_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);
     
-	if (unlikely(ret < 0)) {
+    #if RGA_TEST_FLUSH_TIME
+    ktime_t start;
+    ktime_t end;
+    start = ktime_get();
+    #endif
+
+    ret_timeout = wait_event_interruptible_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);
+    
+	if (unlikely(ret_timeout < 0)) {
 		pr_err("pid %d wait task ret %d\n", session->pid, ret);
-	} else if (0 == ret) {
+        ret = -ETIMEDOUT;
+	} else if (0 == ret_timeout) {
 		pr_err("pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));
 		ret = -ETIMEDOUT;
 	}
+
+    #if RGA_TEST_FLUSH_TIME
+    end = ktime_get();
+    end = ktime_sub(end, start);
+    printk("one flush wait time %d\n", (int)ktime_to_us(end));
+    #endif
     
 	return ret;
 }
@@ -275,9 +292,6 @@ static int rga_get_result(rga_session *session, unsigned long arg)
 			ERR("copy_to_user failed\n");
 			ret =  -EFAULT;	
 		}
-	//idle_condition = 1;
-	//dmac_clean_range((const void*)&idle_condition,(const void*)&idle_condition+4);
-	//wake_up_interruptible_sync(&blit_wait_queue);
 	return ret;
 }
 
@@ -512,19 +526,23 @@ static void rga_try_set_reg(uint32_t num)
         
         return;
     }
-    
+        
 	spin_lock_irqsave(&rga_service.lock, flag);
 	if (!list_empty(&rga_service.waiting)) 
     {
         do
         {            
             struct rga_reg *reg = list_entry(rga_service.waiting.next, struct rga_reg, status_link);
+            
+            //if(((reg->cmd_reg[0] & 0xf0) >= 3) && ((reg->cmd_reg[0] & 0xf0) <= 7) && rga_service.last_prc_src_format == 0)    
+                
             offset = atomic_read(&rga_service.cmd_num);
             if((rga_read(RGA_STATUS) & 0x1)) 
-            {            
+            {   
+                #if 0
                 #if RGA_TEST
                 /* RGA is busy */
-                printk("no idel is here \n");
+                printk(" rga try set reg while rga is working \n");
                 #endif
                 
                 if((atomic_read(&rga_service.cmd_num) <= 0xf) && (atomic_read(&rga_service.int_disable) == 0)) 
@@ -558,6 +576,8 @@ static void rga_try_set_reg(uint32_t num)
                     if(atomic_read(&reg->int_enable))
                         atomic_set(&rga_service.int_disable, 1);
                 }
+                #endif
+                break;
             }
             else 
             {  
@@ -622,6 +642,26 @@ static void rga_try_set_reg(uint32_t num)
 }
 
 
+static void print_info(struct rga_req *req)
+{
+    #if RGA_TEST    
+    printk("src.yrgb_addr = %.8x, src.uv_addr = %.8x, src.v_addr = %.8x\n", 
+            req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr);
+    printk("src : act_w = %d, act_h = %d, vir_w = %d, vir_h = %d\n", 
+        req->src.act_w, req->src.act_h, req->src.vir_w, req->src.vir_h);
+    printk("src : x_offset = %.8x y_offset = %.8x\n", req->src.x_offset, req->src.y_offset);
+    
+    printk("dst.yrgb_addr = %.8x, dst.uv_addr = %.8x, dst.v_addr = %.8x\n", 
+            req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr); 
+    printk("dst : x_offset = %.8x y_offset = %.8x\n", req->dst.x_offset, req->dst.y_offset);
+    printk("dst : act_w = %d, act_h = %d, vir_w = %d, vir_h = %d\n", 
+        req->dst.act_w, req->dst.act_h, req->dst.vir_w, req->dst.vir_h);
+
+    printk("clip.xmin = %d, clip.xmax = %d. clip.ymin = %d, clip.ymax = %d\n", 
+        req->clip.xmin, req->clip.xmax, req->clip.ymin, req->clip.ymax);
+    #endif
+}
+
 
 static int rga_blit_async(rga_session *session, struct rga_req *req)
 {
@@ -635,10 +675,8 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
     req2 = NULL;
 
     #if RGA_TEST
-    printk("src.yrgb_addr = %.8x, src.uv_addr = %.8x, src.v_addr = %.8x\n", 
-            req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr);
-    printk("dst.yrgb_addr = %.8x, dst.uv_addr = %.8x, dst.v_addr = %.8x\n", 
-            req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr);    
+    printk("*** rga_blit_async proc ***\n");
+    print_info(req);
     #endif
             
     saw = req->src.act_w;
@@ -646,6 +684,10 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
     daw = req->dst.act_w;
     dah = req->dst.act_h;
 
+    /* special case proc */
+    if(req->src.act_w == 360 && req->src.act_h == 64 && req->rotate_mode == 0)
+        req->rotate_mode = 1;
+
     do
     {
         if((req->render_mode == bitblt_mode) && (((saw>>1) >= daw) || ((sah>>1) >= dah))) 
@@ -655,6 +697,16 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
             if(NULL == req2) {
                 return -EINVAL;            
             }
+
+            ret = rga_check_param(req);
+        	if(ret == -EINVAL) {
+                break;
+        	}
+
+            ret = rga_check_param(req2);
+        	if(ret == -EINVAL) {
+                break;
+        	}
             
             RGA_gen_two_pro(req, req2);
 
@@ -692,7 +744,7 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
         kfree(req2);
     }
 
-    return ret;
+    return -EFAULT;
 }
 
 static int rga_blit_sync(rga_session *session, struct rga_req *req)
@@ -711,13 +763,15 @@ static int rga_blit_sync(rga_session *session, struct rga_req *req)
     dah = req->dst.act_h;
    
     #if RGA_TEST
-
-    printk("src.yrgb_addr = %.8x, src.uv_addr = %.8x, src.v_addr = %.8x\n", 
-            req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr);
-    printk("dst.yrgb_addr = %.8x, dst.uv_addr = %.8x, dst.v_addr = %.8x\n", 
-            req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr);    
+    printk("*** rga_blit_sync proc ***\n");
+    print_info(req);
     #endif
 
+    /* special case proc*/
+    if(req->src.act_w == 360 && req->src.act_h == 64 && req->rotate_mode == 0)
+        req->rotate_mode = 1;
+        
+
     do
     {
         if((req->render_mode == bitblt_mode) && (((saw>>1) >= daw) || ((sah>>1) >= dah))) 
@@ -762,6 +816,7 @@ static int rga_blit_sync(rga_session *session, struct rga_req *req)
         ret_timeout = wait_event_interruptible_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);
 
         rga_soft_reset();
+        
         if (unlikely(ret_timeout< 0)) 
         {
     		pr_err("pid %d wait task ret %d\n", session->pid, ret_timeout);
@@ -778,7 +833,7 @@ static int rga_blit_sync(rga_session *session, struct rga_req *req)
         printk("one cmd end time %d\n", (int)ktime_to_us(rga_end));
         #endif
 
-        return 0;
+        return ret;
     }
     while(0);
             
@@ -796,7 +851,6 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
     struct rga_req *req;
 	int ret = 0;
     rga_session *session = (rga_session *)file->private_data;
-
     
 	if (NULL == session) 
     {
@@ -827,7 +881,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
         		ERR("copy_from_user failed\n");
         		ret = -EFAULT;
         	}
-			ret = rga_blit_async(session, req);            
+			ret = rga_blit_async(session, req);              
 			break;
 		case RGA_FLUSH:
 			ret = rga_flush(session, arg);
@@ -906,7 +960,7 @@ static irqreturn_t rga_irq(int irq,  void *dev_id)
     struct list_head *next;
     int int_enable = 0;
 
-    DBG("rga_irq %d \n", irq);
+    //DBG("rga_irq %d \n", irq);
     
     #if RGA_TEST
     printk("rga_irq is valid\n");
@@ -918,7 +972,7 @@ static irqreturn_t rga_irq(int irq,  void *dev_id)
 
     if(((rga_read(RGA_STATUS) & 0x1) != 0))// idle
 	{	
-		printk(" INT ERROR RGA is not idle!\n");
+		printk(" irq ERROR : RGA is not idle!\n");
 		rga_soft_reset();
 	}
 
@@ -988,7 +1042,7 @@ static int rga_resume(struct platform_device *pdev)
 static void rga_shutdown(struct platform_device *pdev)
 {
 	pr_cont("shutdown...");	    
-	//rga_power_off(NULL);    
+	//rga_power_off();    
     pr_cont("done\n");
 }
 
@@ -1014,84 +1068,28 @@ static int __devinit rga_drv_probe(struct platform_device *pdev)
 
 	data = kmalloc(sizeof(struct rga_drvdata), GFP_KERNEL);
 
+    memset(data, 0x0, sizeof(struct rga_drvdata));
+
     INIT_LIST_HEAD(&rga_service.waiting);
 	INIT_LIST_HEAD(&rga_service.running);
 	INIT_LIST_HEAD(&rga_service.done);
 	INIT_LIST_HEAD(&rga_service.session);
 	spin_lock_init(&rga_service.lock);
     atomic_set(&rga_service.total_running, 0);
-	rga_service.enabled		= false;    
+    atomic_set(&rga_service.src_format_swt, 0);
+    rga_service.last_prc_src_format = 1; /* default is yuv first*/
+	rga_service.enabled	= false;    
           
 	if(NULL == data)
 	{
 		ERR("failed to allocate driver data.\n");
 		return  -ENOMEM;
 	}
-
-    #if 0
-	/* get the clock */
-	data->pd_display = clk_get(&pdev->dev, "pd_display");
-	if (IS_ERR(data->pd_display))
-	{
-		ERR("failed to find rga pd_display source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-
-	data->aclk_lcdc = clk_get(&pdev->dev, "aclk_lcdc");
-	if (IS_ERR(data->aclk_lcdc))
-	{
-		ERR("failed to find rga aclk_lcdc source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-	
-	data->hclk_lcdc = clk_get(&pdev->dev, "hclk_lcdc");
-	if (IS_ERR(data->hclk_lcdc))
-	{
-		ERR("failed to find rga hclk_lcdc source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-
-	data->aclk_ddr_lcdc = clk_get(&pdev->dev, "aclk_ddr_lcdc");
-	if (IS_ERR(data->aclk_ddr_lcdc))
-	{
-		ERR("failed to find rga aclk_ddr_lcdc source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-
-	data->hclk_cpu_display = clk_get(&pdev->dev, "hclk_cpu_display");
-	if (IS_ERR(data->hclk_cpu_display))
-	{
-		ERR("failed to find rga hclk_cpu_display source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-
-	data->aclk_disp_matrix = clk_get(&pdev->dev, "aclk_disp_matrix");
-	if (IS_ERR(data->aclk_disp_matrix))
-	{
-		ERR("failed to find rga aclk_disp_matrix source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-
-	data->hclk_disp_matrix = clk_get(&pdev->dev, "hclk_disp_matrix");
-	if (IS_ERR(data->hclk_disp_matrix))
-	{
-		ERR("failed to find rga hclk_disp_matrix source\n");
-		ret = -ENOENT;
-		goto err_clock;
-	}
-
-    #endif
 	
 	data->aclk_rga = clk_get(NULL, "aclk_rga");    
 	if (IS_ERR(data->aclk_rga))
 	{
-		ERR("failed to find rga axi clock source\n");
+		ERR("failed to find rga axi clock source.\n");
 		ret = -ENOENT;
 		goto err_clock;
 	}
@@ -1099,10 +1097,12 @@ static int __devinit rga_drv_probe(struct platform_device *pdev)
 	data->hclk_rga = clk_get(NULL, "hclk_rga");
 	if (IS_ERR(data->hclk_rga))
 	{
-		ERR("failed to find rga ahb clock source\n");
+		ERR("failed to find rga ahb clock source.\n");
 		ret = -ENOENT;
 		goto err_clock;
-	}        
+	}
+
+    //rga_power_on();
     
 	/* map the memory */
     if (!request_mem_region(RK30_RGA_PHYS, RK30_RGA_SIZE, "rga_io")) 
@@ -1150,6 +1150,9 @@ static int __devinit rga_drv_probe(struct platform_device *pdev)
 		ERR("cannot register miscdev (%d)\n", ret);
 		goto err_misc_register;
 	}
+
+    //rga_power_off();
+    
 	DBG("RGA Driver loaded succesfully\n");
 
 	return 0;    
@@ -1172,39 +1175,7 @@ static int rga_drv_remove(struct platform_device *pdev)
 
     misc_deregister(&(data->miscdev));
 	free_irq(data->irq0, &data->miscdev);
-    iounmap((void __iomem *)(data->rga_base));
-            
-    #if 0    
-	if(data->axi_clk) {
-		clk_put(data->axi_clk);
-	}
-    
-	if(data->ahb_clk) {
-		clk_put(data->ahb_clk);
-	}
-    
-	if(data->aclk_disp_matrix) {
-		clk_put(data->aclk_disp_matrix);
-	}
-
-	if(data->hclk_disp_matrix) {
-		clk_put(data->hclk_disp_matrix);
-	}
-	
-	
-
-	if(data->aclk_lcdc) {
-		clk_put(data->aclk_lcdc);
-	}
-	
-	if(data->hclk_cpu_display) {
-		clk_put(data->hclk_cpu_display);
-	}
-
-	if(data->pd_display){
-		clk_put(data->pd_display);
-	}
-    #endif
+    iounmap((void __iomem *)(data->rga_base));            
 
     if(data->aclk_rga) {
 		clk_put(data->aclk_rga);
@@ -1281,6 +1252,8 @@ static void __exit rga_exit(void)
 {
     uint32_t i;
 
+    rga_power_off();
+
     for(i=0; i<2048; i++)
     {
         if((uint32_t *)rga_service.pre_scale_buf[i] != NULL)
@@ -1299,6 +1272,8 @@ static void __exit rga_exit(void)
 #if 0
 
 #include "320x240_swap0_Y4200.h"
+#include "320x240_swap0_U4200.h"
+#include "320x240_swap0_V4200.h"
 #include "320x240_swap0_UV4200.h"
 #include "320x240_swap0_ABGR8888.h"
 
@@ -1309,6 +1284,7 @@ EXPORT_SYMBOL(rk_get_fb);
 extern void rk_direct_fb_show(struct fb_info * fbi);
 EXPORT_SYMBOL(rk_direct_fb_show);
 
+unsigned int src_buf[360*64];
 unsigned int dst_buf[1280*800];
 
 void rga_test_0(void)
@@ -1333,16 +1309,18 @@ void rga_test_0(void)
     fb = rk_get_fb(0);
 
     memset(&req, 0, sizeof(struct rga_req));
-    src = Y4200_320_240_swap0;
+    src = src_buf;
     dst = dst_buf;
+
+    memset(src_buf, 0x80, 360*64*4);
+
+    dmac_flush_range(&src_buf[0], &src_buf[360*64]);
+    outer_flush_range(virt_to_phys(&src_buf[0]),virt_to_phys(&src_buf[360*64]));
         
     #if 0
     memset(src_buf, 0x80, 800*480*4);
     memset(dst_buf, 0xcc, 800*480*4);
-
-    dmac_flush_range(&src_buf[0], &src_buf[800*480]);
-    outer_flush_range(virt_to_phys(&src_buf[0]),virt_to_phys(&src_buf[800*480]));
-    
+        
     dmac_flush_range(&dst_buf[0], &dst_buf[800*480]);
     outer_flush_range(virt_to_phys(&dst_buf[0]),virt_to_phys(&dst_buf[800*480]));
     #endif
@@ -1352,17 +1330,18 @@ void rga_test_0(void)
 
     req.src.vir_w = 320;
     req.src.vir_h = 240;
-    req.src.yrgb_addr = (uint32_t)src;
-    req.src.uv_addr = (uint32_t)UV4200_320_240_swap0;
-    req.src.format = 0xa;
+    req.src.yrgb_addr = (uint32_t)Y4200_320_240_swap0;
+    req.src.uv_addr = (uint32_t)U4200_320_240_swap0;
+    req.src.v_addr = (uint32_t)V4200_320_240_swap0;
+    req.src.format = RK_FORMAT_YCbCr_420_P;
 
-    req.dst.act_w = 100;
-    req.dst.act_h = 80;
+    req.dst.act_w = 320;
+    req.dst.act_h = 240;
 
     req.dst.vir_w = 1280;
     req.dst.vir_h = 800;
-    req.dst.x_offset = 0;
-    req.dst.y_offset = 000;
+    req.dst.x_offset = 100;
+    req.dst.y_offset = 100;
     req.dst.yrgb_addr = (uint32_t)dst;
 
     req.clip.xmin = 0;
@@ -1370,8 +1349,8 @@ void rga_test_0(void)
     req.clip.ymin = 0;
     req.clip.ymax = 799;
             
-    req.rotate_mode = 1;
-    req.scale_mode = 2;
+    req.rotate_mode = 0;
+    req.scale_mode = 0;
 
     req.alpha_rop_flag = 0;
 
diff --git a/drivers/video/rockchip/rga/rga_mmu_info.c b/drivers/video/rockchip/rga/rga_mmu_info.c
index d9f4af01fa8d..aa4c373d2860 100755
--- a/drivers/video/rockchip/rga/rga_mmu_info.c
+++ b/drivers/video/rockchip/rga/rga_mmu_info.c
@@ -22,6 +22,8 @@ extern int mmu_buff_temp[1024];
 
 #define KERNEL_SPACE_VALID    0xc0000000
 
+int mmu_flag = 0;
+
 static int rga_mem_size_cal(uint32_t Mem, uint32_t MemSize, uint32_t *StartAddr) 
 {
     uint32_t start, end;
@@ -72,7 +74,6 @@ static int rga_buf_size_cal(uint32_t yrgb_addr, uint32_t uv_addr, uint32_t v_add
             end = (yrgb_addr + (size_yrgb + PAGE_SIZE - 1)) >> PAGE_SHIFT;
             start = yrgb_addr >> PAGE_SHIFT;
             pageCount = end - start;
-            *StartAddr = start;
             break;
         case RK_FORMAT_RGB_565 :
             stride = (w*2 + 3) & (~3);            
@@ -381,11 +382,16 @@ static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)
 
     MMU_Base = NULL;
 
+    if(req->src.act_w == 360 && req->src.act_h == 64)
+        mmu_flag = 1;
+    else
+        mmu_flag = 0;
+
     do
     {               
         /* cal src buf mmu info */                     
         SrcMemSize = rga_buf_size_cal(req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr,
-                                        req->src.format, req->src.vir_w, (req->src.act_h + req->src.y_offset),
+                                        req->src.format, req->src.vir_w, req->src.vir_h,
                                         &SrcStart);
         if(SrcMemSize == 0) {
             return -EINVAL;                
@@ -394,8 +400,8 @@ static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)
 
         /* cal dst buf mmu info */    
         DstMemSize = rga_buf_size_cal(req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr,
-                                        req->dst.format, req->dst.vir_w, (req->dst.act_h + req->dst.y_offset),
-                                        &DstStart);
+                                        req->dst.format, req->dst.vir_w, req->dst.vir_h,
+                                        &DstStart);        
         if(DstMemSize == 0) {
             return -EINVAL; 
         }
@@ -405,7 +411,6 @@ static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)
         if(CMDMemSize == 0) {
             return -EINVAL; 
         }
-
         
         /* Cal out the needed mem size */
         AllSize = SrcMemSize + DstMemSize + CMDMemSize;
@@ -500,7 +505,7 @@ static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)
         
         req->src.yrgb_addr = (req->src.yrgb_addr & (~PAGE_MASK)) | (CMDMemSize << PAGE_SHIFT);
         req->src.uv_addr = (req->src.uv_addr & (~PAGE_MASK)) | ((CMDMemSize + uv_size) << PAGE_SHIFT);
-        req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | ((CMDMemSize + v_size) << PAGE_SHIFT);        
+        req->src.v_addr = (req->src.v_addr & (~PAGE_MASK)) | ((CMDMemSize + v_size) << PAGE_SHIFT);
 
         req->dst.yrgb_addr = (req->dst.yrgb_addr & (~PAGE_MASK)) | ((CMDMemSize + SrcMemSize) << PAGE_SHIFT);