modify rga driver for fix bugs

diff --git a/drivers/video/rockchip/rga/RGA_API.c b/drivers/video/rockchip/rga/RGA_API.c
index b97337213dac71bff4f31cb55a21f2df0286a27e..08dc712d436c210d25007616570c76b4bae55522 100755 (executable)
--- a/drivers/video/rockchip/rga/RGA_API.c
+++ b/drivers/video/rockchip/rga/RGA_API.c
@@ -142,8 +142,6 @@ uint32_t RGA_gen_two_pro(struct rga_req *msg, struct rga_req *msg1)
             msg->src.act_h = (dah - 1) << 3;                                                    \r
         }\r
     }\r
-\r
-    printk("test_2\n");\r
     \r
     msg->dst.act_h = dah;\r
     msg->dst.vir_h = dah;\r

diff --git a/drivers/video/rockchip/rga/rga.h b/drivers/video/rockchip/rga/rga.h
index e102c7014d63a7088ac4c4e0bd86ea36eced0795..01b94b4e9a5d2f4a069c4641624a3bf9ddb9b119 100755 (executable)
--- a/drivers/video/rockchip/rga/rga.h
+++ b/drivers/video/rockchip/rga/rga.h
@@ -1,6 +1,7 @@
 #ifndef _RGA_DRIVER_H_\r
 #define _RGA_DRIVER_H_\r
 \r
+#include <linux/mutex.h>\r
 \r
 #define RGA_BLIT_SYNC  0x5017\r
 #define RGA_BLIT_ASYNC  0x5018\r
@@ -374,6 +375,8 @@ typedef struct rga_service_info {
     atomic_t            cmd_num;\r
     atomic_t            src_format_swt;\r
     int                 last_prc_src_format;\r
+\r
+    struct mutex       mutex;  // mutex\r
 } rga_service_info;\r
 \r
 \r

diff --git a/drivers/video/rockchip/rga/rga_drv.c b/drivers/video/rockchip/rga/rga_drv.c
index 2d5995722783e03480470eba2e6ec39014bbb2c5..32a2503a4242cc22353d5267b279c532a0587a5d 100755 (executable)
--- a/drivers/video/rockchip/rga/rga_drv.c
+++ b/drivers/video/rockchip/rga/rga_drv.c
@@ -50,7 +50,7 @@
 #include "RGA_API.h"\r
 \r
 \r
-#define RGA_TEST 0\r
+#define RGA_TEST 1\r
 #define RGA_TEST_TIME 0\r
 #define RGA_TEST_FLUSH_TIME 0\r
 \r
@@ -73,6 +73,8 @@
 ktime_t rga_start;\r
 ktime_t rga_end;\r
 \r
+int num = 0;\r
+\r
 struct rga_drvdata {\r
        struct miscdevice miscdev;\r
        struct device dev;\r
@@ -82,8 +84,6 @@ struct rga_drvdata {
        struct clk *aclk_rga;\r
        struct clk *hclk_rga;\r
        \r
-       struct mutex    mutex;  // mutex\r
-       \r
        struct delayed_work power_off_work;\r
        bool enable;                                                    //clk enable or disable\r
        void (*rga_irq_callback)(int rga_retval);   //callback function used by aync call\r
@@ -94,6 +94,7 @@ static struct rga_drvdata *drvdata = NULL;
 rga_service_info rga_service;\r
 \r
 static int rga_blit_async(rga_session *session, struct rga_req *req);\r
+static void rga_del_running_list(void);\r
 \r
 \r
 /* Logging */\r
@@ -243,10 +244,10 @@ static void rga_power_off(void)
 }\r
 \r
 \r
+\r
+\r
 static int rga_flush(rga_session *session, unsigned long arg)\r
-{\r
-       //printk("rga_get_result %d\n",drvdata->rga_result);\r
-       \r
+{      \r
     int ret = 0;\r
     int ret_timeout;\r
 \r
@@ -258,12 +259,16 @@ static int rga_flush(rga_session *session, unsigned long arg)
     #endif\r
 \r
     ret_timeout = wait_event_interruptible_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);\r
+\r
+    rga_soft_reset();\r
     \r
        if (unlikely(ret_timeout < 0)) {\r
-               pr_err("pid %d wait task ret %d\n", session->pid, ret);\r
+               pr_err("flush pid %d wait task ret %d\n", session->pid, ret);\r
+        rga_del_running_list();\r
         ret = -ETIMEDOUT;\r
        } else if (0 == ret_timeout) {\r
-               pr_err("pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));\r
+               pr_err("flush pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));\r
+        rga_del_running_list();\r
                ret = -ETIMEDOUT;\r
        }\r
 \r
@@ -325,19 +330,6 @@ static int rga_check_param(const struct rga_req *req)
                return  -EINVAL;\r
        }\r
 \r
-       //check src address\r
-       if (unlikely(req->src.yrgb_addr == 0))\r
-       {\r
-               ERR("could not retrieve src image from memory\n");\r
-               return  -EINVAL;\r
-       }\r
-    \r
-       //check src address\r
-       if (unlikely(req->dst.yrgb_addr == 0))\r
-       {\r
-               ERR("could not retrieve dst image from memory\n");\r
-               return  -EINVAL;\r
-       }\r
        #endif\r
        \r
        \r
@@ -393,17 +385,8 @@ static struct rga_reg * rga_reg_init(rga_session *session, struct rga_req *req)
         }\r
     }\r
 \r
-    #if RGA_TEST_TIME\r
-    rga_start = ktime_get();\r
-    #endif        \r
     RGA_gen_reg_info(req, (uint8_t *)reg->cmd_reg);\r
 \r
-    #if RGA_TEST_TIME\r
-    rga_end = ktime_get();\r
-    rga_end = ktime_sub(rga_end, rga_start);\r
-    printk("one cmd end time %d\n", (int)ktime_to_us(rga_end));\r
-    #endif\r
-\r
     spin_lock_irqsave(&rga_service.lock, flag);\r
        list_add_tail(&reg->status_link, &rga_service.waiting);\r
        list_add_tail(&reg->session_link, &session->waiting);\r
@@ -454,7 +437,6 @@ static struct rga_reg * rga_reg_init_2(rga_session *session, struct rga_req *req
         }\r
         \r
         RGA_gen_reg_info(req0, (uint8_t *)reg0->cmd_reg);\r
-\r
         \r
         if(req1->mmu_info.mmu_en)\r
         {\r
@@ -525,7 +507,6 @@ static void rga_service_session_clear(rga_session *session)
 static void rga_try_set_reg(uint32_t num)\r
 {\r
     unsigned long flag;\r
-    uint32_t offset;\r
     \r
     if (!num)\r
     {\r
@@ -540,16 +521,17 @@ static void rga_try_set_reg(uint32_t num)
        if (!list_empty(&rga_service.waiting)) \r
     {\r
         do\r
-        {            \r
-            struct rga_reg *reg = list_entry(rga_service.waiting.next, struct rga_reg, status_link);\r
-            offset = atomic_read(&rga_service.cmd_num);\r
+        {                        \r
             if((rga_read(RGA_STATUS) & 0x1)) \r
             {                   \r
                 break;\r
             }\r
             else \r
             {  \r
-                /* RGA is idle */                \r
+                struct rga_reg *reg = list_entry(rga_service.waiting.next, struct rga_reg, status_link);\r
+                /* RGA is idle */\r
+                rga_soft_reset();\r
+                rga_del_running_list();\r
                 rga_copy_reg(reg, 0);            \r
                 rga_reg_from_wait_to_run(reg);\r
                 \r
@@ -585,7 +567,8 @@ static void rga_try_set_reg(uint32_t num)
                                                 \r
                 /* Start proc */\r
                 atomic_set(&reg->session->done, 0);\r
-                rga_write(0x1, RGA_CMD_CTRL);                \r
+                rga_write(0x1, RGA_CMD_CTRL);\r
+                //rga_write(0x1<<1, RGA_SYS_CTRL);\r
 \r
                 #if RGA_TEST\r
                 {\r
@@ -626,21 +609,43 @@ static void print_info(struct rga_req *req)
 #endif\r
 \r
 \r
-static int rga_blit_async(rga_session *session, struct rga_req *req)\r
+static void rga_del_running_list(void)\r
 {\r
-       int ret = -1;\r
+    struct rga_reg *reg;\r
+    \r
+    while(!list_empty(&rga_service.running))\r
+    {\r
+        reg = list_entry(rga_service.running.next, struct rga_reg, status_link);\r
+\r
+        if(reg->MMU_base != NULL)\r
+        {\r
+            kfree(reg->MMU_base);\r
+        }\r
+                \r
+        atomic_sub(1, &reg->session->task_running);\r
+           atomic_sub(1, &rga_service.total_running);\r
+        \r
+        if(list_empty(&reg->session->waiting))\r
+        {\r
+            atomic_set(&reg->session->done, 1);\r
+            wake_up_interruptible_sync(&reg->session->wait);\r
+        }\r
+        \r
+        rga_reg_deinit(reg);        \r
+    }    \r
+}\r
+\r
+\r
+static int rga_blit(rga_session *session, struct rga_req *req)\r
+{\r
+    int ret = -1;\r
     int num = 0; \r
     struct rga_reg *reg;\r
     struct rga_req *req2;\r
 \r
     uint32_t saw, sah, daw, dah;\r
 \r
-    req2 = NULL;\r
-\r
-    #if RGA_TEST\r
-    printk("*** rga_blit_async proc ***\n");\r
-    print_info(req);\r
-    #endif\r
+    req2 = NULL;    \r
                   \r
     saw = req->src.act_w;\r
     sah = req->src.act_h;\r
@@ -648,7 +653,7 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
     dah = req->dst.act_h;\r
 \r
     do\r
-    {\r
+    {                \r
         if((req->render_mode == bitblt_mode) && (((saw>>1) >= daw) || ((sah>>1) >= dah))) \r
         {                                   \r
             /* generate 2 cmd for pre scale */        \r
@@ -680,12 +685,12 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
             /* check value if legal */\r
             ret = rga_check_param(req);\r
                if(ret == -EINVAL) {\r
-                return -EINVAL;\r
+                break;\r
                }\r
            \r
             reg = rga_reg_init(session, req);\r
             if(reg == NULL) {\r
-                return -EFAULT;\r
+                break;\r
             }            \r
             num = 1;       \r
         }        \r
@@ -706,97 +711,60 @@ static int rga_blit_async(rga_session *session, struct rga_req *req)
     return -EFAULT;\r
 }\r
 \r
+static int rga_blit_async(rga_session *session, struct rga_req *req)\r
+{\r
+       int ret = -1;\r
+    \r
+    #if RGA_TEST\r
+    printk("*** rga_blit_async proc ***\n");\r
+    print_info(req);\r
+    #endif\r
+                  \r
+    ret = rga_blit(session, req);\r
+    \r
+    return ret;\r
+}\r
+\r
 static int rga_blit_sync(rga_session *session, struct rga_req *req)\r
 {\r
-    int ret = 0;\r
+    int ret = -1;\r
     int ret_timeout = 0;\r
-    int num = 0;\r
-    struct rga_reg *reg;\r
-    struct rga_req *req2;\r
-\r
-    uint32_t saw, sah, daw, dah;\r
-        \r
-    saw = req->src.act_w;\r
-    sah = req->src.act_h;\r
-    daw = req->dst.act_w;\r
-    dah = req->dst.act_h;\r
-   \r
+       \r
     #if RGA_TEST\r
     printk("*** rga_blit_sync proc ***\n");\r
     print_info(req);\r
     #endif\r
-       \r
-    do\r
-    {\r
-        if((req->render_mode == bitblt_mode) && (((saw>>1) >= daw) || ((sah>>1) >= dah))) \r
-        {\r
-            /* generate 2 cmd for pre scale */\r
-            \r
-            req2 = kmalloc(sizeof(struct rga_req), GFP_KERNEL);\r
-            if (NULL == req2) \r
-            {\r
-                return -EINVAL;            \r
-            }\r
-            memset(req2, 0, sizeof(struct rga_req));\r
-            \r
-            RGA_gen_two_pro(req, req2);\r
-\r
-            reg = rga_reg_init_2(session, req, req2);\r
-            if (NULL == reg)  \r
-            {\r
-                break;\r
-            }\r
-            num = 2;        \r
-        }\r
-        else \r
-        {\r
-            /* check value if legal */        \r
-            ret = rga_check_param(req);\r
-               if(ret == -EINVAL)  {\r
-                       return -EFAULT;\r
-               }\r
-          \r
-            reg = rga_reg_init(session, req);\r
-            if(reg == NULL)  {            \r
-                return -EFAULT;\r
-            }\r
-            num = 1;        \r
-        }    \r
-\r
-        //rga_power_on();\r
-        atomic_set(&reg->int_enable, 1);        \r
-        rga_try_set_reg(num);\r
-        \r
-        ret_timeout = wait_event_interruptible_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);\r
 \r
-        rga_soft_reset();\r
+    #if RGA_TEST_TIME\r
+    rga_start = ktime_get();\r
+    #endif \r
+                     \r
+    ret = rga_blit(session, req);\r
         \r
-        if (unlikely(ret_timeout< 0)) \r
-        {\r
-               pr_err("pid %d wait task ret %d\n", session->pid, ret_timeout);\r
-       } \r
-        else if (0 == ret_timeout)\r
-        {\r
-               pr_err("pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));\r
-               ret = -ETIMEDOUT;\r
-       }\r
+    ret_timeout = wait_event_interruptible_timeout(session->wait, atomic_read(&session->done), RGA_TIMEOUT_DELAY);\r
 \r
-        #if RGA_TEST_TIME\r
-        rga_end = ktime_get();\r
-        rga_end = ktime_sub(rga_end, rga_start);\r
-        printk("one cmd end time %d\n", (int)ktime_to_us(rga_end));\r
-        #endif\r
+    rga_soft_reset();\r
+    \r
+    if (unlikely(ret_timeout< 0)) \r
+    {\r
+               pr_err("pid %d wait task ret %d\n", session->pid, ret_timeout);\r
+        rga_del_running_list();\r
+        ret = -ETIMEDOUT;\r
+       } \r
+    else if (0 == ret_timeout)\r
+    {\r
+               pr_err("pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));\r
+        rga_del_running_list();\r
+               ret = -ETIMEDOUT;\r
+       }\r
 \r
-        return ret;\r
-    }\r
-    while(0);\r
+    #if RGA_TEST_TIME\r
+    rga_end = ktime_get();\r
+    rga_end = ktime_sub(rga_end, rga_start);\r
+    printk("one cmd end time %d\n", (int)ktime_to_us(rga_end));\r
+    #endif\r
             \r
-    if(NULL != req2)\r
-    {\r
-        kfree(req2);\r
-    }\r
-        \r
-    return -EFAULT;   \r
+    return ret;   \r
 }\r
 \r
 \r
@@ -812,13 +780,16 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
                return -EINVAL;\r
        }\r
 \r
+    mutex_lock(&rga_service.mutex);\r
+     \r
     req = (struct rga_req *)kmalloc(sizeof(struct rga_req), GFP_KERNEL);\r
     if(req == NULL) \r
     {\r
         printk("%s [%d] get rga_req mem failed\n",__FUNCTION__,__LINE__);\r
-        ret = -EINVAL;\r
+        mutex_unlock(&rga_service.mutex);\r
+        return -EINVAL;\r
     }\r
-       \r
+           \r
        switch (cmd)\r
        {\r
                case RGA_BLIT_SYNC:\r
@@ -826,6 +797,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
             {\r
                        ERR("copy_from_user failed\n");\r
                        ret = -EFAULT;\r
+                break;\r
                }\r
             ret = rga_blit_sync(session, req);\r
             break;\r
@@ -834,6 +806,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
             {\r
                        ERR("copy_from_user failed\n");\r
                        ret = -EFAULT;\r
+                break;\r
                }\r
                        ret = rga_blit_async(session, req);              \r
                        break;\r
@@ -850,7 +823,9 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
 \r
     if(req != NULL) {\r
         kfree(req);\r
-    }    \r
+    }\r
+        \r
+    mutex_unlock(&rga_service.mutex);\r
         \r
        return ret;\r
 }\r
@@ -874,6 +849,7 @@ static int rga_open(struct inode *inode, struct file *file)
     atomic_set(&session->num_done, 0);\r
        file->private_data = (void *)session;\r
 \r
+    DBG("*** rga opened by pid %d *** \n", session->pid);    \r
        DBG("*** rga dev opened *** \n");\r
        return nonseekable_open(inode, file);\r
     \r
@@ -889,10 +865,10 @@ static int rga_release(struct inode *inode, struct file *file)
     \r
        task_running = atomic_read(&session->task_running);\r
 \r
-    while (task_running) \r
+    if (task_running) \r
     {\r
                pr_err("rga_service session %d still has %d task running when closing\n", session->pid, task_running);\r
-               msleep(50);\r
+               msleep(100);\r
         /*ͬ²½*/        \r
        }\r
     \r
@@ -909,10 +885,10 @@ static int rga_release(struct inode *inode, struct file *file)
 \r
 static irqreturn_t rga_irq(int irq,  void *dev_id)\r
 {\r
-    struct rga_reg *reg;\r
-    uint32_t num = 0;\r
+    //struct rga_reg *reg;\r
+    //uint32_t num = 0;\r
     struct list_head *next;\r
-    int int_enable = 0;\r
+    //int int_enable = 0;\r
     \r
     #if RGA_TEST\r
     printk("rga_irq is valid\n");\r
@@ -931,34 +907,19 @@ static irqreturn_t rga_irq(int irq,  void *dev_id)
     rga_soft_reset();\r
     \r
     spin_lock(&rga_service.lock);\r
-    do\r
-    {\r
-        reg = list_entry(rga_service.running.next, struct rga_reg, status_link);\r
 \r
-        if(reg->MMU_base != NULL)\r
-        {\r
-            kfree(reg->MMU_base);\r
-        }\r
-                \r
-        atomic_sub(1, &reg->session->task_running);\r
-           atomic_sub(1, &rga_service.total_running);\r
-        \r
-        if(list_empty(&reg->session->waiting))\r
-        {\r
-            atomic_set(&reg->session->done, 1);\r
-            wake_up_interruptible_sync(&reg->session->wait);\r
-        }\r
-        \r
-        rga_reg_deinit(reg);\r
-        \r
-    }\r
-    while(!list_empty(&rga_service.running));\r
+    rga_del_running_list();\r
 \r
     atomic_set(&rga_service.cmd_num, 0);\r
 \r
     spin_unlock(&rga_service.lock);\r
 \r
     next = &rga_service.waiting;\r
+\r
+    if(!list_empty(next))\r
+    {\r
+        rga_try_set_reg(1);\r
+    }\r
    \r
     /* add cmd to cmd buf */\r
     /*\r
@@ -970,8 +931,7 @@ static irqreturn_t rga_irq(int irq,  void *dev_id)
         next = next->next;\r
     } \r
     */\r
-    rga_try_set_reg(1);\r
-                       \r
+                               \r
        return IRQ_HANDLED;\r
 }\r
 \r
@@ -1087,7 +1047,7 @@ static int __devinit rga_drv_probe(struct platform_device *pdev)
                goto err_irq;\r
        }\r
 \r
-       mutex_init(&data->mutex);\r
+       mutex_init(&rga_service.mutex);\r
        data->enable = false;\r
        INIT_DELAYED_WORK(&data->power_off_work, rga_power_off);\r
        data->rga_irq_callback = NULL;\r
@@ -1235,8 +1195,8 @@ EXPORT_SYMBOL(rk_get_fb);
 extern void rk_direct_fb_show(struct fb_info * fbi);\r
 EXPORT_SYMBOL(rk_direct_fb_show);\r
 \r
-unsigned int src_buf[360*64];\r
-unsigned int dst_buf[1280*800];\r
+unsigned int src_buf[1024*1000];\r
+unsigned int dst_buf[1280*1280];\r
 \r
 void rga_test_0(void)\r
 {\r
@@ -1263,10 +1223,10 @@ void rga_test_0(void)
     src = src_buf;\r
     dst = dst_buf;\r
 \r
-    memset(src_buf, 0x80, 360*64*4);\r
+    memset(src_buf, 0x80, 1024*1000*4);\r
 \r
-    dmac_flush_range(&src_buf[0], &src_buf[360*64]);\r
-    outer_flush_range(virt_to_phys(&src_buf[0]),virt_to_phys(&src_buf[360*64]));\r
+    dmac_flush_range(&src_buf[0], &src_buf[1024*1000]);\r
+    outer_flush_range(virt_to_phys(&src_buf[0]),virt_to_phys(&src_buf[1024*1000]));\r
         \r
     #if 0\r
     memset(src_buf, 0x80, 800*480*4);\r
@@ -1281,31 +1241,35 @@ void rga_test_0(void)
 \r
     req.src.vir_w = 320;\r
     req.src.vir_h = 240;\r
-    req.src.yrgb_addr = (uint32_t)Y4200_320_240_swap0;\r
-    req.src.uv_addr = (uint32_t)U4200_320_240_swap0;\r
-    req.src.v_addr = (uint32_t)V4200_320_240_swap0;\r
-    req.src.format = RK_FORMAT_YCbCr_420_P;\r
+    //req.src.yrgb_addr = (uint32_t)virt_to_phys(src_buf);\r
+    //req.src.uv_addr = (uint32_t)U4200_320_240_swap0;\r
+    //req.src.v_addr = (uint32_t)V4200_320_240_swap0;\r
+    req.src.format = RK_FORMAT_RGBA_8888;\r
 \r
     req.dst.act_w = 320;\r
     req.dst.act_h = 240;\r
 \r
     req.dst.vir_w = 1280;\r
     req.dst.vir_h = 800;\r
-    req.dst.x_offset = 100;\r
-    req.dst.y_offset = 100;\r
+    req.dst.x_offset = 0;\r
+    req.dst.y_offset = 000;\r
     req.dst.yrgb_addr = (uint32_t)dst;\r
 \r
     req.clip.xmin = 0;\r
     req.clip.xmax = 1279;\r
     req.clip.ymin = 0;\r
     req.clip.ymax = 799;\r
+\r
+    req.render_mode = color_fill_mode;\r
+    req.fg_color = 0x80808080;\r
             \r
-    req.rotate_mode = 0;\r
+    req.rotate_mode = 1;\r
     req.scale_mode = 0;\r
 \r
-    req.alpha_rop_flag = 0;\r
+    req.alpha_rop_flag = 1;\r
+    req.alpha_global_value = 0x80;\r
 \r
-    req.sina = 0;\r
+    req.sina = 0x00000;\r
     req.cosa = 0x10000;\r
 \r
     req.mmu_info.mmu_flag = 0x21;\r
@@ -1327,6 +1291,10 @@ void rga_test_0(void)
     fb->var.green.msb_right = 0;\r
     \r
     fb->var.blue.length = 8;\r
+\r
+\r
+\r
+    \r
     fb->var.blue.offset = 16;\r
     fb->var.blue.msb_right = 0;\r
     \r

diff --git a/drivers/video/rockchip/rga/rga_mmu_info.c b/drivers/video/rockchip/rga/rga_mmu_info.c
index e598fb041e2181bcabff61038f630c88869ce1d5..66210c07f2d0b8341e7eac56a2a4faaf15989f69 100755 (executable)
--- a/drivers/video/rockchip/rga/rga_mmu_info.c
+++ b/drivers/video/rockchip/rga/rga_mmu_info.c
@@ -402,7 +402,8 @@ static int rga_mmu_info_BitBlt_mode(struct rga_reg *reg, struct rga_req *req)
         }\r
 \r
         //DstMemSize += 1;\r
-\r
+        \r
+        CMDMemSize = 0;\r
         /* cal cmd buf mmu info */\r
         CMDMemSize = rga_mem_size_cal((uint32_t)rga_service.cmd_buff, RGA_CMD_BUF_SIZE, &CMDStart);\r
         if(CMDMemSize == 0) {\r

diff --git a/drivers/video/rockchip/rga/rga_reg_info.c b/drivers/video/rockchip/rga/rga_reg_info.c
index fe50ef0b1da5f27602f7e6329b2ffa1a0dfba625..9386feb0b7b3df1aa8ee108f6db0645e0ecf8f35 100755 (executable)
--- a/drivers/video/rockchip/rga/rga_reg_info.c
+++ b/drivers/video/rockchip/rga/rga_reg_info.c
@@ -1290,9 +1290,6 @@ RGA_set_pre_scale_reg_info(u8 *base, const struct rga_req *msg)
    dst_width = msg->dst.act_w;\r
    dst_height = msg->dst.act_h;\r
 \r
-   printk("src_act_w = %.8x, src_act_h =%.8x dst_act_w = %.8x, dst_act_h = %.8x\n", \r
-    msg->src.act_w, msg->src.act_h, msg->dst.act_w, msg->dst.act_h);\r
-\r
    h_ratio = (src_width <<16) / dst_width;\r
    v_ratio = (src_height<<16) / dst_height;\r
 \r