drivers/video/rockchip/rga2/rga2_drv.c

   1 /*\r
   2  * Copyright (C) 2012 ROCKCHIP, Inc.\r
   3  *\r
   4  * This software is licensed under the terms of the GNU General Public\r
   5  * License version 2, as published by the Free Software Foundation, and\r
   6  * may be copied, distributed, and modified under those terms.\r
   7  *\r
   8  * This program is distributed in the hope that it will be useful,\r
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  11  * GNU General Public License for more details.\r
  12  *\r
  13  */\r
  14 \r
  15 #define pr_fmt(fmt) "rga: " fmt\r
  16 #include <linux/kernel.h>\r
  17 #include <linux/init.h>\r
  18 #include <linux/module.h>\r
  19 #include <linux/platform_device.h>\r
  20 #include <linux/sched.h>\r
  21 #include <linux/mutex.h>\r
  22 #include <linux/err.h>\r
  23 #include <linux/clk.h>\r
  24 #include <asm/delay.h>\r
  25 #include <linux/dma-mapping.h>\r
  26 #include <linux/delay.h>\r
  27 #include <asm/io.h>\r
  28 #include <linux/irq.h>\r
  29 #include <linux/interrupt.h>\r
  30 #include <mach/io.h>\r
  31 #include <mach/irqs.h>\r
  32 #include <linux/fs.h>\r
  33 #include <asm/uaccess.h>\r
  34 #include <linux/miscdevice.h>\r
  35 #include <linux/poll.h>\r
  36 #include <linux/delay.h>\r
  37 #include <linux/wait.h>\r
  38 #include <linux/syscalls.h>\r
  39 #include <linux/timer.h>\r
  40 #include <linux/time.h>\r
  41 #include <asm/cacheflush.h>\r
  42 #include <linux/slab.h>\r
  43 #include <linux/fb.h>\r
  44 #include <linux/wakelock.h>\r
  45 \r
  46 #include "rga2.h"\r
  47 #include "rga2_reg_info.h"\r
  48 #include "rga2_mmu_info.h"\r
  49 #include "RGA2_API.h"\r
  50 \r
  51 \r
  52 #define RGA2_TEST_FLUSH_TIME 0\r
  53 #define RGA2_INFO_BUS_ERROR 1\r
  54 \r
  55 #define RGA2_POWER_OFF_DELAY    4*HZ /* 4s */\r
  56 #define RGA2_TIMEOUT_DELAY      2*HZ /* 2s */\r
  57 \r
  58 #define RGA2_MAJOR              255\r
  59 \r
  60 #define RGA2_RESET_TIMEOUT      1000\r
  61 \r
  62 /* Driver information */\r
  63 #define DRIVER_DESC             "RGA2 Device Driver"\r
  64 #define DRIVER_NAME             "rga2"\r
  65 \r
  66 #define RGA2_VERSION   "2.000"\r
  67 \r
  68 ktime_t rga_start;\r
  69 ktime_t rga_end;\r
  70 \r
  71 int rga2_flag = 0;\r
  72 \r
  73 rga2_session rga2_session_global;\r
  74 \r
  75 struct rga2_drvdata_t {\r
  76         struct miscdevice miscdev;\r
  77         struct device dev;\r
  78         void *rga_base;\r
  79         int irq;\r
  80 \r
  81         struct delayed_work power_off_work;\r
  82         void (*rga_irq_callback)(int rga_retval);   //callback function used by aync call\r
  83         struct wake_lock wake_lock;\r
  84 \r
  85         struct clk *aclk_rga2;\r
  86         struct clk *hclk_rga2;\r
  87         struct clk *pd_rga2;\r
  88     struct clk *rga2;\r
  89 };\r
  90 \r
  91 struct rga2_drvdata_t *rga2_drvdata;\r
  92 \r
  93 struct rga2_service_info rga2_service;\r
  94 struct rga2_mmu_buf_t rga2_mmu_buf;\r
  95 \r
  96 static int rga2_blit_async(rga2_session *session, struct rga2_req *req);\r
  97 static void rga2_del_running_list(void);\r
  98 static void rga2_del_running_list_timeout(void);\r
  99 static void rga2_try_set_reg(void);\r
 100 \r
 101 \r
 102 /* Logging */\r
 103 #define RGA_DEBUG 0\r
 104 #if RGA_DEBUG\r
 105 #define DBG(format, args...) printk(KERN_DEBUG "%s: " format, DRIVER_NAME, ## args)\r
 106 #define ERR(format, args...) printk(KERN_ERR "%s: " format, DRIVER_NAME, ## args)\r
 107 #define WARNING(format, args...) printk(KERN_WARN "%s: " format, DRIVER_NAME, ## args)\r
 108 #define INFO(format, args...) printk(KERN_INFO "%s: " format, DRIVER_NAME, ## args)\r
 109 #else\r
 110 #define DBG(format, args...)\r
 111 #define ERR(format, args...)\r
 112 #define WARNING(format, args...)\r
 113 #define INFO(format, args...)\r
 114 #endif\r
 115 \r
 116 #if RGA2_TEST_MSG\r
 117 static void print_info(struct rga2_req *req)\r
 118 {\r
 119     printk("render_mode=%d bitblt_mode=%d rotate_mode=%.8x\n",\r
 120             req->render_mode, req->bitblt_mode, req->rotate_mode);\r
 121     printk("src : y=%.8x uv=%.8x v=%.8x format=%d aw=%d ah=%d vw=%d vh=%d xoff=%d yoff=%d \n",\r
 122             req->src.yrgb_addr, req->src.uv_addr, req->src.v_addr, req->src.format,\r
 123             req->src.act_w, req->src.act_h, req->src.vir_w, req->src.vir_h,\r
 124             req->src.x_offset, req->src.y_offset);\r
 125     printk("dst : y=%.8x uv=%.8x v=%.8x format=%d aw=%d ah=%d vw=%d vh=%d xoff=%d yoff=%d \n",\r
 126             req->dst.yrgb_addr, req->dst.uv_addr, req->dst.v_addr, req->dst.format,\r
 127             req->dst.act_w, req->dst.act_h, req->dst.vir_w, req->dst.vir_h,\r
 128             req->dst.x_offset, req->dst.y_offset);\r
 129     printk("mmu : src=%.2x src1=%.2x dst=%.2x els=%.2x\n",\r
 130             req->mmu_info.src0_mmu_flag, req->mmu_info.src1_mmu_flag,\r
 131             req->mmu_info.dst_mmu_flag,  req->mmu_info.els_mmu_flag);\r
 132     printk("alpha : flag %.8x mode0=%.8x mode1=%.8x\n",\r
 133             req->alpha_rop_flag, req->alpha_mode_0, req->alpha_mode_1);\r
 134 }\r
 135 #endif\r
 136 \r
 137 \r
 138 static inline void rga2_write(u32 b, u32 r)\r
 139 {\r
 140         __raw_writel(b, rga2_drvdata->rga_base + r);\r
 141 }\r
 142 \r
 143 static inline u32 rga2_read(u32 r)\r
 144 {\r
 145         return __raw_readl(rga2_drvdata->rga_base + r);\r
 146 }\r
 147 \r
 148 static void rga2_soft_reset(void)\r
 149 {\r
 150         u32 i;\r
 151         u32 reg;\r
 152 \r
 153         rga2_write(1, RGA2_SYS_CTRL); //RGA_SYS_CTRL\r
 154 \r
 155         for(i = 0; i < RGA2_RESET_TIMEOUT; i++)\r
 156         {\r
 157                 reg = rga2_read(RGA2_SYS_CTRL) & 1; //RGA_SYS_CTRL\r
 158 \r
 159                 if(reg == 0)\r
 160                         break;\r
 161 \r
 162                 udelay(1);\r
 163         }\r
 164 \r
 165         if(i == RGA2_RESET_TIMEOUT)\r
 166                 ERR("soft reset timeout.\n");\r
 167 }\r
 168 \r
 169 static void rga2_dump(void)\r
 170 {\r
 171         int running;\r
 172     struct rga2_reg *reg, *reg_tmp;\r
 173     rga2_session *session, *session_tmp;\r
 174 \r
 175         running = atomic_read(&rga2_service.total_running);\r
 176         printk("rga total_running %d\n", running);\r
 177 \r
 178     #if 0\r
 179 \r
 180     /* Dump waiting list info */\r
 181     if (!list_empty(&rga_service.waiting))\r
 182     {\r
 183         list_head       *next;\r
 184 \r
 185         next = &rga_service.waiting;\r
 186 \r
 187         printk("rga_service dump waiting list\n");\r
 188 \r
 189         do\r
 190         {\r
 191             reg = list_entry(next->next, struct rga_reg, status_link);\r
 192             running = atomic_read(&reg->session->task_running);\r
 193             num_done = atomic_read(&reg->session->num_done);\r
 194             printk("rga session pid %d, done %d, running %d\n", reg->session->pid, num_done, running);\r
 195             next = next->next;\r
 196         }\r
 197         while(!list_empty(next));\r
 198     }\r
 199 \r
 200     /* Dump running list info */\r
 201     if (!list_empty(&rga_service.running))\r
 202     {\r
 203         printk("rga_service dump running list\n");\r
 204 \r
 205         list_head       *next;\r
 206 \r
 207         next = &rga_service.running;\r
 208         do\r
 209         {\r
 210             reg = list_entry(next->next, struct rga_reg, status_link);\r
 211             running = atomic_read(&reg->session->task_running);\r
 212             num_done = atomic_read(&reg->session->num_done);\r
 213             printk("rga session pid %d, done %d, running %d:\n", reg->session->pid, num_done, running);\r
 214             next = next->next;\r
 215         }\r
 216         while(!list_empty(next));\r
 217     }\r
 218     #endif\r
 219 \r
 220         list_for_each_entry_safe(session, session_tmp, &rga2_service.session, list_session)\r
 221     {\r
 222                 printk("session pid %d:\n", session->pid);\r
 223                 running = atomic_read(&session->task_running);\r
 224                 printk("task_running %d\n", running);\r
 225                 list_for_each_entry_safe(reg, reg_tmp, &session->waiting, session_link)\r
 226         {\r
 227                         printk("waiting register set 0x%.8x\n", (unsigned int)reg);\r
 228                 }\r
 229                 list_for_each_entry_safe(reg, reg_tmp, &session->running, session_link)\r
 230         {\r
 231                         printk("running register set 0x%.8x\n", (unsigned int)reg);\r
 232                 }\r
 233         }\r
 234 }\r
 235 \r
 236 static inline void rga2_queue_power_off_work(void)\r
 237 {\r
 238         queue_delayed_work(system_nrt_wq, &rga2_drvdata->power_off_work, RGA2_POWER_OFF_DELAY);\r
 239 }\r
 240 \r
 241 /* Caller must hold rga_service.lock */\r
 242 static void rga2_power_on(void)\r
 243 {\r
 244         static ktime_t last;\r
 245         ktime_t now = ktime_get();\r
 246 \r
 247         if (ktime_to_ns(ktime_sub(now, last)) > NSEC_PER_SEC) {\r
 248                 cancel_delayed_work_sync(&rga2_drvdata->power_off_work);\r
 249                 rga2_queue_power_off_work();\r
 250                 last = now;\r
 251         }\r
 252         if (rga2_service.enable)\r
 253                 return;\r
 254 \r
 255     //clk_enable(rga2_drvdata->rga2);\r
 256         clk_prepare_enable(rga2_drvdata->aclk_rga2);\r
 257         clk_prepare_enable(rga2_drvdata->hclk_rga2);\r
 258         //clk_enable(rga2_drvdata->pd_rga2);\r
 259         wake_lock(&rga2_drvdata->wake_lock);\r
 260         rga2_service.enable = true;\r
 261 }\r
 262 \r
 263 /* Caller must hold rga_service.lock */\r
 264 static void rga2_power_off(void)\r
 265 {\r
 266         int total_running;\r
 267 \r
 268         if (!rga2_service.enable) {\r
 269                 return;\r
 270         }\r
 271 \r
 272         total_running = atomic_read(&rga2_service.total_running);\r
 273         if (total_running) {\r
 274                 pr_err("power off when %d task running!!\n", total_running);\r
 275                 mdelay(50);\r
 276                 pr_err("delay 50 ms for running task\n");\r
 277                 rga2_dump();\r
 278         }\r
 279 \r
 280         //clk_disable(rga2_drvdata->pd_rga2);\r
 281     //clk_disable(rga2_drvdata->rga2);\r
 282         clk_disable_unprepare(rga2_drvdata->aclk_rga2);\r
 283         clk_disable_unprepare(rga2_drvdata->hclk_rga2);\r
 284         wake_unlock(&rga2_drvdata->wake_lock);\r
 285         rga2_service.enable = false;\r
 286 }\r
 287 \r
 288 static void rga2_power_off_work(struct work_struct *work)\r
 289 {\r
 290         if (mutex_trylock(&rga2_service.lock)) {\r
 291                 rga2_power_off();\r
 292                 mutex_unlock(&rga2_service.lock);\r
 293         } else {\r
 294                 /* Come back later if the device is busy... */\r
 295                 rga2_queue_power_off_work();\r
 296         }\r
 297 }\r
 298 \r
 299 static int rga2_flush(rga2_session *session, unsigned long arg)\r
 300 {\r
 301     int ret = 0;\r
 302     int ret_timeout;\r
 303 \r
 304     #if RGA2_TEST_FLUSH_TIME\r
 305     ktime_t start;\r
 306     ktime_t end;\r
 307     start = ktime_get();\r
 308     #endif\r
 309 \r
 310     ret_timeout = wait_event_timeout(session->wait, atomic_read(&session->done), RGA2_TIMEOUT_DELAY);\r
 311 \r
 312         if (unlikely(ret_timeout < 0)) {\r
 313                 //pr_err("flush pid %d wait task ret %d\n", session->pid, ret);\r
 314         mutex_lock(&rga2_service.lock);\r
 315         rga2_del_running_list();\r
 316         mutex_unlock(&rga2_service.lock);\r
 317         ret = ret_timeout;\r
 318         } else if (0 == ret_timeout) {\r
 319                 //pr_err("flush pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));\r
 320         //printk("bus  = %.8x\n", rga_read(RGA_INT));\r
 321         mutex_lock(&rga2_service.lock);\r
 322         rga2_del_running_list_timeout();\r
 323         rga2_try_set_reg();\r
 324         mutex_unlock(&rga2_service.lock);\r
 325                 ret = -ETIMEDOUT;\r
 326         }\r
 327 \r
 328     #if RGA2_TEST_FLUSH_TIME\r
 329     end = ktime_get();\r
 330     end = ktime_sub(end, start);\r
 331     printk("one flush wait time %d\n", (int)ktime_to_us(end));\r
 332     #endif\r
 333 \r
 334         return ret;\r
 335 }\r
 336 \r
 337 \r
 338 static int rga2_get_result(rga2_session *session, unsigned long arg)\r
 339 {\r
 340         //printk("rga_get_result %d\n",drvdata->rga_result);\r
 341 \r
 342     int ret = 0;\r
 343 \r
 344     int num_done;\r
 345 \r
 346     num_done = atomic_read(&session->num_done);\r
 347 \r
 348         if (unlikely(copy_to_user((void __user *)arg, &num_done, sizeof(int)))) {\r
 349                         printk("copy_to_user failed\n");\r
 350                         ret =  -EFAULT;\r
 351                 }\r
 352         return ret;\r
 353 }\r
 354 \r
 355 \r
 356 static int rga2_check_param(const struct rga2_req *req)\r
 357 {\r
 358     /*RGA2 can support up to 8192*8192 resolution in RGB format,but we limit the image size to 8191*8191 here*/\r
 359         //check src width and height\r
 360 \r
 361     if(!((req->render_mode == color_fill_mode)))\r
 362     {\r
 363         if (unlikely((req->src.act_w <= 0) || (req->src.act_w > 8191) || (req->src.act_h <= 0) || (req->src.act_h > 8191)))\r
 364         {\r
 365                 printk("invalid source resolution act_w = %d, act_h = %d\n", req->src.act_w, req->src.act_h);\r
 366                 return  -EINVAL;\r
 367         }\r
 368     }\r
 369 \r
 370     if(!((req->render_mode == color_fill_mode)))\r
 371     {\r
 372         if (unlikely((req->src.vir_w <= 0) || (req->src.vir_w > 8191) || (req->src.vir_h <= 0) || (req->src.vir_h > 8191)))\r
 373         {\r
 374                 printk("invalid source resolution vir_w = %d, vir_h = %d\n", req->src.vir_w, req->src.vir_h);\r
 375                 return  -EINVAL;\r
 376         }\r
 377     }\r
 378 \r
 379         //check dst width and height\r
 380         if (unlikely((req->dst.act_w <= 0) || (req->dst.act_w > 4096) || (req->dst.act_h <= 0) || (req->dst.act_h > 4096)))\r
 381     {\r
 382                 printk("invalid destination resolution act_w = %d, act_h = %d\n", req->dst.act_w, req->dst.act_h);\r
 383                 return  -EINVAL;\r
 384         }\r
 385 \r
 386     if (unlikely((req->dst.vir_w <= 0) || (req->dst.vir_w > 4096) || (req->dst.vir_h <= 0) || (req->dst.vir_h > 4096)))\r
 387     {\r
 388                 printk("invalid destination resolution vir_w = %d, vir_h = %d\n", req->dst.vir_w, req->dst.vir_h);\r
 389                 return  -EINVAL;\r
 390         }\r
 391 \r
 392         //check src_vir_w\r
 393         if(unlikely(req->src.vir_w < req->src.act_w)){\r
 394                 printk("invalid src_vir_w act_w = %d, vir_w = %d\n", req->src.act_w, req->src.vir_w);\r
 395                 return  -EINVAL;\r
 396         }\r
 397 \r
 398         //check dst_vir_w\r
 399         if(unlikely(req->dst.vir_w < req->dst.act_w)){\r
 400         if(req->rotate_mode != 1)\r
 401         {\r
 402                     printk("invalid dst_vir_w act_h = %d, vir_h = %d\n", req->dst.act_w, req->dst.vir_w);\r
 403                     return      -EINVAL;\r
 404         }\r
 405         }\r
 406 \r
 407         return 0;\r
 408 }\r
 409 \r
 410 static void rga2_copy_reg(struct rga2_reg *reg, uint32_t offset)\r
 411 {\r
 412     uint32_t i;\r
 413     uint32_t *cmd_buf;\r
 414     uint32_t *reg_p;\r
 415 \r
 416     if(atomic_read(&reg->session->task_running) != 0)\r
 417     {\r
 418         printk(KERN_ERR "task_running is no zero\n");\r
 419     }\r
 420 \r
 421     atomic_add(1, &rga2_service.cmd_num);\r
 422         atomic_add(1, &reg->session->task_running);\r
 423 \r
 424     cmd_buf = (uint32_t *)rga2_service.cmd_buff + offset*32;\r
 425     reg_p = (uint32_t *)reg->cmd_reg;\r
 426 \r
 427     for(i=0; i<32; i++)\r
 428     {\r
 429         cmd_buf[i] = reg_p[i];\r
 430     }\r
 431 \r
 432     dsb();\r
 433 }\r
 434 \r
 435 \r
 436 static struct rga2_reg * rga2_reg_init(rga2_session *session, struct rga2_req *req)\r
 437 {\r
 438     uint32_t ret;\r
 439         struct rga2_reg *reg = kzalloc(sizeof(struct rga2_reg), GFP_KERNEL);\r
 440         if (NULL == reg) {\r
 441                 pr_err("kmalloc fail in rga_reg_init\n");\r
 442                 return NULL;\r
 443         }\r
 444 \r
 445     reg->session = session;\r
 446         INIT_LIST_HEAD(&reg->session_link);\r
 447         INIT_LIST_HEAD(&reg->status_link);\r
 448 \r
 449     reg->MMU_base = NULL;\r
 450 \r
 451     if ((req->mmu_info.src0_mmu_flag & 1) || (req->mmu_info.src1_mmu_flag & 1)\r
 452         || (req->mmu_info.dst_mmu_flag & 1) || (req->mmu_info.els_mmu_flag & 1))\r
 453     {\r
 454         ret = rga2_set_mmu_info(reg, req);\r
 455         if(ret < 0)\r
 456         {\r
 457             printk("%s, [%d] set mmu info error \n", __FUNCTION__, __LINE__);\r
 458             if(reg != NULL)\r
 459             {\r
 460                 kfree(reg);\r
 461             }\r
 462             return NULL;\r
 463         }\r
 464     }\r
 465 \r
 466     if(RGA2_gen_reg_info((uint8_t *)reg->cmd_reg, req) == -1)\r
 467     {\r
 468         printk("gen reg info error\n");\r
 469         if(reg != NULL)\r
 470         {\r
 471             kfree(reg);\r
 472         }\r
 473         return NULL;\r
 474     }\r
 475 \r
 476     mutex_lock(&rga2_service.lock);\r
 477         list_add_tail(&reg->status_link, &rga2_service.waiting);\r
 478         list_add_tail(&reg->session_link, &session->waiting);\r
 479         mutex_unlock(&rga2_service.lock);\r
 480 \r
 481     return reg;\r
 482 }\r
 483 \r
 484 \r
 485 /* Caller must hold rga_service.lock */\r
 486 static void rga2_reg_deinit(struct rga2_reg *reg)\r
 487 {\r
 488         list_del_init(&reg->session_link);\r
 489         list_del_init(&reg->status_link);\r
 490         kfree(reg);\r
 491 }\r
 492 \r
 493 /* Caller must hold rga_service.lock */\r
 494 static void rga2_reg_from_wait_to_run(struct rga2_reg *reg)\r
 495 {\r
 496         list_del_init(&reg->status_link);\r
 497         list_add_tail(&reg->status_link, &rga2_service.running);\r
 498 \r
 499         list_del_init(&reg->session_link);\r
 500         list_add_tail(&reg->session_link, &reg->session->running);\r
 501 }\r
 502 \r
 503 /* Caller must hold rga_service.lock */\r
 504 static void rga2_service_session_clear(rga2_session *session)\r
 505 {\r
 506         struct rga2_reg *reg, *n;\r
 507 \r
 508     list_for_each_entry_safe(reg, n, &session->waiting, session_link)\r
 509     {\r
 510                 rga2_reg_deinit(reg);\r
 511         }\r
 512 \r
 513     list_for_each_entry_safe(reg, n, &session->running, session_link)\r
 514     {\r
 515                 rga2_reg_deinit(reg);\r
 516         }\r
 517 }\r
 518 \r
 519 /* Caller must hold rga_service.lock */\r
 520 static void rga2_try_set_reg(void)\r
 521 {\r
 522     struct rga2_reg *reg ;\r
 523 \r
 524     if (list_empty(&rga2_service.running))\r
 525     {\r
 526         if (!list_empty(&rga2_service.waiting))\r
 527         {\r
 528             /* RGA is idle */\r
 529             reg = list_entry(rga2_service.waiting.next, struct rga2_reg, status_link);\r
 530 \r
 531             rga2_power_on();\r
 532             udelay(1);\r
 533 \r
 534             rga2_copy_reg(reg, 0);\r
 535             rga2_reg_from_wait_to_run(reg);\r
 536 \r
 537             dmac_flush_range(&rga2_service.cmd_buff[0], &rga2_service.cmd_buff[32]);\r
 538             outer_flush_range(virt_to_phys(&rga2_service.cmd_buff[0]),virt_to_phys(&rga2_service.cmd_buff[32]));\r
 539 \r
 540             #if defined(CONFIG_ARCH_RK30)\r
 541             rga2_soft_reset();\r
 542             #endif\r
 543 \r
 544             rga2_write(0x0, RGA2_SYS_CTRL);\r
 545             //rga2_write(0, RGA_MMU_CTRL);\r
 546 \r
 547             /* CMD buff */\r
 548             rga2_write(virt_to_phys(rga2_service.cmd_buff), RGA2_CMD_BASE);\r
 549 \r
 550 #if RGA2_TEST\r
 551             if(rga2_flag)\r
 552             {\r
 553                 //printk(KERN_DEBUG "cmd_addr = %.8x\n", rga_read(RGA_CMD_ADDR));\r
 554                 uint32_t i, *p;\r
 555                 p = rga2_service.cmd_buff;\r
 556                 printk("CMD_REG\n");\r
 557                 for (i=0; i<8; i++)\r
 558                     printk("%.8x %.8x %.8x %.8x\n", p[0 + i*4], p[1+i*4], p[2 + i*4], p[3 + i*4]);\r
 559             }\r
 560 #endif\r
 561 \r
 562             /* master mode */\r
 563             rga2_write((0x1<<1)|(0x1<<2)|(0x1<<5)|(0x1<<6), RGA2_SYS_CTRL);\r
 564 \r
 565             /* All CMD finish int */\r
 566             rga2_write(rga2_read(RGA2_INT)|(0x1<<10)|(0x1<<8), RGA2_INT);\r
 567 \r
 568             #if RGA2_TEST_TIME\r
 569             rga_start = ktime_get();\r
 570             #endif\r
 571 \r
 572             /* Start proc */\r
 573             atomic_set(&reg->session->done, 0);\r
 574             rga2_write(0x1, RGA2_CMD_CTRL);\r
 575 #if RGA2_TEST\r
 576             if(rga2_flag)\r
 577             {\r
 578                 uint32_t i;\r
 579                 printk("CMD_READ_BACK_REG\n");\r
 580                 for (i=0; i<8; i++)\r
 581                     printk("%.8x %.8x %.8x %.8x\n", rga2_read(0x100 + i*16 + 0),\r
 582                             rga2_read(0x100 + i*16 + 4), rga2_read(0x100 + i*16 + 8), rga2_read(0x100 + i*16 + 12));\r
 583             }\r
 584 #endif\r
 585         }\r
 586     }\r
 587 }\r
 588 \r
 589 \r
 590 \r
 591 \r
 592 /* Caller must hold rga_service.lock */\r
 593 static void rga2_del_running_list(void)\r
 594 {\r
 595     struct rga2_reg *reg;\r
 596 \r
 597     while(!list_empty(&rga2_service.running))\r
 598     {\r
 599         reg = list_entry(rga2_service.running.next, struct rga2_reg, status_link);\r
 600 \r
 601         if(reg->MMU_len != 0)\r
 602         {\r
 603             if (rga2_mmu_buf.back + reg->MMU_len > 2*rga2_mmu_buf.size)\r
 604                 rga2_mmu_buf.back = reg->MMU_len + rga2_mmu_buf.size;\r
 605             else\r
 606                 rga2_mmu_buf.back += reg->MMU_len;\r
 607         }\r
 608         atomic_sub(1, &reg->session->task_running);\r
 609         atomic_sub(1, &rga2_service.total_running);\r
 610 \r
 611         if(list_empty(&reg->session->waiting))\r
 612         {\r
 613             atomic_set(&reg->session->done, 1);\r
 614             wake_up(&reg->session->wait);\r
 615         }\r
 616 \r
 617         rga2_reg_deinit(reg);\r
 618     }\r
 619 }\r
 620 \r
 621 /* Caller must hold rga_service.lock */\r
 622 static void rga2_del_running_list_timeout(void)\r
 623 {\r
 624     struct rga2_reg *reg;\r
 625 \r
 626     while(!list_empty(&rga2_service.running))\r
 627     {\r
 628         reg = list_entry(rga2_service.running.next, struct rga2_reg, status_link);\r
 629 \r
 630         if(reg->MMU_base != NULL)\r
 631         {\r
 632             kfree(reg->MMU_base);\r
 633         }\r
 634 \r
 635         atomic_sub(1, &reg->session->task_running);\r
 636         atomic_sub(1, &rga2_service.total_running);\r
 637 \r
 638         //printk("RGA soft reset for timeout process\n");\r
 639         rga2_soft_reset();\r
 640 \r
 641 \r
 642         #if 0\r
 643         printk("RGA_INT is %.8x\n", rga_read(RGA_INT));\r
 644         printk("reg->session->task_running = %d\n", atomic_read(&reg->session->task_running));\r
 645         printk("rga_service.total_running  = %d\n", atomic_read(&rga_service.total_running));\r
 646 \r
 647         print_info(&reg->req);\r
 648 \r
 649         {\r
 650             uint32_t *p, i;\r
 651             p = reg->cmd_reg;\r
 652             for (i=0; i<7; i++)\r
 653                 printk("%.8x %.8x %.8x %.8x\n", p[0 + i*4], p[1+i*4], p[2 + i*4], p[3 + i*4]);\r
 654 \r
 655         }\r
 656         #endif\r
 657 \r
 658         if(list_empty(&reg->session->waiting))\r
 659         {\r
 660             atomic_set(&reg->session->done, 1);\r
 661             wake_up(&reg->session->wait);\r
 662         }\r
 663 \r
 664         rga2_reg_deinit(reg);\r
 665     }\r
 666 }\r
 667 \r
 668 \r
 669 static void rga2_mem_addr_sel(struct rga2_req *req)\r
 670 {\r
 671 }\r
 672 \r
 673 \r
 674 static int rga2_blit(rga2_session *session, struct rga2_req *req)\r
 675 {\r
 676     int ret = -1;\r
 677     int num = 0;\r
 678     struct rga2_reg *reg;\r
 679 \r
 680     do\r
 681     {\r
 682         /* check value if legal */\r
 683         ret = rga2_check_param(req);\r
 684         if(ret == -EINVAL) {\r
 685             printk("req argument is inval\n");\r
 686             break;\r
 687         }\r
 688 \r
 689         reg = rga2_reg_init(session, req);\r
 690         if(reg == NULL) {\r
 691             break;\r
 692         }\r
 693         num = 1;\r
 694 \r
 695         mutex_lock(&rga2_service.lock);\r
 696         atomic_add(num, &rga2_service.total_running);\r
 697         rga2_try_set_reg();\r
 698         mutex_unlock(&rga2_service.lock);\r
 699 \r
 700         return 0;\r
 701     }\r
 702     while(0);\r
 703 \r
 704     return -EFAULT;\r
 705 }\r
 706 \r
 707 static int rga2_blit_async(rga2_session *session, struct rga2_req *req)\r
 708 {\r
 709         int ret = -1;\r
 710 \r
 711     #if RGA2_TEST_MSG\r
 712     //printk("*** rga_blit_async proc ***\n");\r
 713     if (req->src.format >= 0x10) {\r
 714         print_info(req);\r
 715         rga2_flag = 1;\r
 716         printk("*** rga_blit_async proc ***\n");\r
 717     }\r
 718     else\r
 719         rga2_flag = 0;\r
 720     #endif\r
 721     atomic_set(&session->done, 0);\r
 722     ret = rga2_blit(session, req);\r
 723 \r
 724     return ret;\r
 725 }\r
 726 \r
 727 static int rga2_blit_sync(rga2_session *session, struct rga2_req *req)\r
 728 {\r
 729     int ret = -1;\r
 730     int ret_timeout = 0;\r
 731 \r
 732     #if RGA2_TEST_MSG\r
 733     if (req->src.format >= 0x10) {\r
 734         print_info(req);\r
 735         rga2_flag = 1;\r
 736         printk("*** rga2_blit_sync proc ***\n");\r
 737     }\r
 738     else\r
 739         rga2_flag = 0;\r
 740     #endif\r
 741 \r
 742     atomic_set(&session->done, 0);\r
 743 \r
 744     ret = rga2_blit(session, req);\r
 745     if(ret < 0)\r
 746     {\r
 747         return ret;\r
 748     }\r
 749 \r
 750     ret_timeout = wait_event_timeout(session->wait, atomic_read(&session->done), RGA2_TIMEOUT_DELAY);\r
 751 \r
 752     if (unlikely(ret_timeout< 0))\r
 753     {\r
 754                 //pr_err("sync pid %d wait task ret %d\n", session->pid, ret_timeout);\r
 755         mutex_lock(&rga2_service.lock);\r
 756         rga2_del_running_list();\r
 757         mutex_unlock(&rga2_service.lock);\r
 758         ret = ret_timeout;\r
 759         }\r
 760     else if (0 == ret_timeout)\r
 761     {\r
 762                 //pr_err("sync pid %d wait %d task done timeout\n", session->pid, atomic_read(&session->task_running));\r
 763         mutex_lock(&rga2_service.lock);\r
 764         rga2_del_running_list_timeout();\r
 765         rga2_try_set_reg();\r
 766         mutex_unlock(&rga2_service.lock);\r
 767                 ret = -ETIMEDOUT;\r
 768         }\r
 769 \r
 770     #if RGA2_TEST_TIME\r
 771     rga_end = ktime_get();\r
 772     rga_end = ktime_sub(rga_end, rga_start);\r
 773     printk("sync one cmd end time %d\n", (int)ktime_to_us(rga_end));\r
 774     #endif\r
 775 \r
 776     return ret;\r
 777 }\r
 778 \r
 779 \r
 780 static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)\r
 781 {\r
 782     struct rga2_req req;\r
 783     struct rga_req req_rga;\r
 784         int ret = 0;\r
 785     rga2_session *session;\r
 786 \r
 787     mutex_lock(&rga2_service.mutex);\r
 788 \r
 789     session = (rga2_session *)file->private_data;\r
 790 \r
 791         if (NULL == session)\r
 792     {\r
 793         printk("%s [%d] rga thread session is null\n",__FUNCTION__,__LINE__);\r
 794         mutex_unlock(&rga2_service.mutex);\r
 795                 return -EINVAL;\r
 796         }\r
 797 \r
 798     memset(&req, 0x0, sizeof(req));\r
 799 \r
 800         switch (cmd)\r
 801         {\r
 802         case RGA_BLIT_SYNC:\r
 803 \r
 804                 if (unlikely(copy_from_user(&req_rga, (struct rga_req*)arg, sizeof(struct rga_req))))\r
 805             {\r
 806                         ERR("copy_from_user failed\n");\r
 807                         ret = -EFAULT;\r
 808                 break;\r
 809                 }\r
 810             RGA_MSG_2_RGA2_MSG(&req_rga, &req);\r
 811 \r
 812             ret = rga2_blit_sync(session, &req);\r
 813             break;\r
 814                 case RGA_BLIT_ASYNC:\r
 815                 if (unlikely(copy_from_user(&req_rga, (struct rga_req*)arg, sizeof(struct rga_req))))\r
 816             {\r
 817                         ERR("copy_from_user failed\n");\r
 818                         ret = -EFAULT;\r
 819                 break;\r
 820                 }\r
 821 \r
 822             RGA_MSG_2_RGA2_MSG(&req_rga, &req);\r
 823 \r
 824             if((atomic_read(&rga2_service.total_running) > 8))\r
 825             {\r
 826                             ret = rga2_blit_sync(session, &req);\r
 827             }\r
 828             else\r
 829             {\r
 830                 ret = rga2_blit_async(session, &req);\r
 831             }\r
 832                         break;\r
 833                 case RGA2_BLIT_SYNC:\r
 834                 if (unlikely(copy_from_user(&req, (struct rga2_req*)arg, sizeof(struct rga2_req))))\r
 835             {\r
 836                         ERR("copy_from_user failed\n");\r
 837                         ret = -EFAULT;\r
 838                 break;\r
 839                 }\r
 840             ret = rga2_blit_sync(session, &req);\r
 841             break;\r
 842                 case RGA2_BLIT_ASYNC:\r
 843                 if (unlikely(copy_from_user(&req, (struct rga2_req*)arg, sizeof(struct rga2_req))))\r
 844             {\r
 845                         ERR("copy_from_user failed\n");\r
 846                         ret = -EFAULT;\r
 847                 break;\r
 848                 }\r
 849 \r
 850             if((atomic_read(&rga2_service.total_running) > 16))\r
 851             {\r
 852                             ret = rga2_blit_sync(session, &req);\r
 853             }\r
 854             else\r
 855             {\r
 856                 ret = rga2_blit_async(session, &req);\r
 857             }\r
 858                         break;\r
 859         case RGA_FLUSH:\r
 860                 case RGA2_FLUSH:\r
 861                         ret = rga2_flush(session, arg);\r
 862                         break;\r
 863         case RGA_GET_RESULT:\r
 864         case RGA2_GET_RESULT:\r
 865             ret = rga2_get_result(session, arg);\r
 866             break;\r
 867         case RGA_GET_VERSION:\r
 868         case RGA2_GET_VERSION:\r
 869             ret = copy_to_user((void *)arg, RGA2_VERSION, sizeof(RGA2_VERSION));\r
 870             //ret = 0;\r
 871             break;\r
 872                 default:\r
 873                         ERR("unknown ioctl cmd!\n");\r
 874                         ret = -EINVAL;\r
 875                         break;\r
 876         }\r
 877 \r
 878         mutex_unlock(&rga2_service.mutex);\r
 879 \r
 880         return ret;\r
 881 }\r
 882 \r
 883 \r
 884 long rga_ioctl_kernel(struct rga_req *req)\r
 885 {\r
 886         int ret = 0;\r
 887     rga2_session *session;\r
 888     struct rga2_req req_rga2;\r
 889 \r
 890     mutex_lock(&rga2_service.mutex);\r
 891 \r
 892     session = &rga2_session_global;\r
 893 \r
 894         if (NULL == session)\r
 895     {\r
 896         printk("%s [%d] rga thread session is null\n",__FUNCTION__,__LINE__);\r
 897         mutex_unlock(&rga2_service.mutex);\r
 898                 return -EINVAL;\r
 899         }\r
 900 \r
 901     RGA_MSG_2_RGA2_MSG(req, &req_rga2);\r
 902     ret = rga2_blit_sync(session, &req_rga2);\r
 903 \r
 904         mutex_unlock(&rga2_service.mutex);\r
 905 \r
 906         return ret;\r
 907 }\r
 908 \r
 909 \r
 910 static int rga2_open(struct inode *inode, struct file *file)\r
 911 {\r
 912     rga2_session *session = kzalloc(sizeof(rga2_session), GFP_KERNEL);\r
 913         if (NULL == session) {\r
 914                 pr_err("unable to allocate memory for rga_session.");\r
 915                 return -ENOMEM;\r
 916         }\r
 917 \r
 918         session->pid = current->pid;\r
 919     //printk(KERN_DEBUG  "+");\r
 920 \r
 921         INIT_LIST_HEAD(&session->waiting);\r
 922         INIT_LIST_HEAD(&session->running);\r
 923         INIT_LIST_HEAD(&session->list_session);\r
 924         init_waitqueue_head(&session->wait);\r
 925         mutex_lock(&rga2_service.lock);\r
 926         list_add_tail(&session->list_session, &rga2_service.session);\r
 927         mutex_unlock(&rga2_service.lock);\r
 928         atomic_set(&session->task_running, 0);\r
 929     atomic_set(&session->num_done, 0);\r
 930 \r
 931         file->private_data = (void *)session;\r
 932 \r
 933     //DBG("*** rga dev opened by pid %d *** \n", session->pid);\r
 934         return nonseekable_open(inode, file);\r
 935 \r
 936 }\r
 937 \r
 938 static int rga2_release(struct inode *inode, struct file *file)\r
 939 {\r
 940     int task_running;\r
 941         rga2_session *session = (rga2_session *)file->private_data;\r
 942         if (NULL == session)\r
 943                 return -EINVAL;\r
 944     //printk(KERN_DEBUG  "-");\r
 945         task_running = atomic_read(&session->task_running);\r
 946 \r
 947     if (task_running)\r
 948     {\r
 949                 pr_err("rga2_service session %d still has %d task running when closing\n", session->pid, task_running);\r
 950                 msleep(100);\r
 951         /*Í¬²½*/\r
 952         }\r
 953 \r
 954         wake_up(&session->wait);\r
 955         mutex_lock(&rga2_service.lock);\r
 956         list_del(&session->list_session);\r
 957         rga2_service_session_clear(session);\r
 958         kfree(session);\r
 959         mutex_unlock(&rga2_service.lock);\r
 960 \r
 961     //DBG("*** rga dev close ***\n");\r
 962         return 0;\r
 963 }\r
 964 \r
 965 static irqreturn_t rga2_irq_thread(int irq, void *dev_id)\r
 966 {\r
 967         mutex_lock(&rga2_service.lock);\r
 968         if (rga2_service.enable) {\r
 969                 rga2_del_running_list();\r
 970                 rga2_try_set_reg();\r
 971         }\r
 972         mutex_unlock(&rga2_service.lock);\r
 973 \r
 974         return IRQ_HANDLED;\r
 975 }\r
 976 \r
 977 static irqreturn_t rga2_irq(int irq,  void *dev_id)\r
 978 {\r
 979         /*clear INT */\r
 980         rga2_write(rga2_read(RGA2_INT) | (0x1<<4) | (0x1<<5) | (0x1<<6) | (0x1<<7), RGA2_INT);\r
 981 \r
 982         return IRQ_WAKE_THREAD;\r
 983 }\r
 984 \r
 985 struct file_operations rga2_fops = {\r
 986         .owner          = THIS_MODULE,\r
 987         .open           = rga2_open,\r
 988         .release        = rga2_release,\r
 989         .unlocked_ioctl         = rga_ioctl,\r
 990 };\r
 991 \r
 992 static struct miscdevice rga2_dev ={\r
 993     .minor = RGA2_MAJOR,\r
 994     .name  = "rga",\r
 995     .fops  = &rga2_fops,\r
 996 };\r
 997 \r
 998 static const struct of_device_id rockchip_rga_of_match[] = {\r
 999         { .compatible = "rockchip,rga", .data = NULL, },\r
1000         {},\r
1001 };\r
1002 \r
1003 static int __devinit rga2_drv_probe(struct platform_device *pdev)\r
1004 {\r
1005         struct rga2_drvdata_t *data;\r
1006     struct resource *res;\r
1007     struct device_node *np = pdev->dev.of_node;\r
1008         int ret = 0;\r
1009 \r
1010         mutex_init(&rga2_service.lock);\r
1011         mutex_init(&rga2_service.mutex);\r
1012         atomic_set(&rga2_service.total_running, 0);\r
1013         atomic_set(&rga2_service.src_format_swt, 0);\r
1014         rga2_service.last_prc_src_format = 1; /* default is yuv first*/\r
1015         rga2_service.enable = false;\r
1016 \r
1017         data = devm_kzalloc(&pdev->dev, sizeof(struct rga2_drvdata_t), GFP_KERNEL);\r
1018         if(NULL == data)\r
1019         {\r
1020                 ERR("failed to allocate driver data.\n");\r
1021                 return -ENOMEM;\r
1022         }\r
1023 \r
1024         INIT_DELAYED_WORK(&data->power_off_work, rga2_power_off_work);\r
1025         wake_lock_init(&data->wake_lock, WAKE_LOCK_SUSPEND, "rga");\r
1026 \r
1027         //data->pd_rga2 = clk_get(NULL, "pd_rga");\r
1028     //data->rga2 = clk_get(NULL, "rga");\r
1029         data->aclk_rga = devm_clk_get(&pdev->dev, "aclk_rga");\r
1030     data->hclk_rga = devm_clk_get(&pdev->dev, "hclk_rga");\r
1031 \r
1032         /* map the registers */\r
1033         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);\r
1034         data->rga_base = devm_ioremap_resource(&pdev->dev, res);\r
1035         if (!data->rga_base) {\r
1036                 ERR("rga ioremap failed\n");\r
1037                 ret = -ENOENT;\r
1038                 goto err_ioremap;\r
1039         }\r
1040 \r
1041         /* get the IRQ */\r
1042         data->irq = platform_get_irq(pdev, 0);\r
1043         if (data->irq <= 0) {\r
1044                 ERR("failed to get rga irq resource (%d).\n", data->irq);\r
1045                 ret = data->irq;\r
1046                 goto err_irq;\r
1047         }\r
1048 \r
1049         /* request the IRQ */\r
1050         ret = devm_request_threaded_irq(&pdev->dev, data->irq, rga2_irq, rga2_irq_thread, 0, "rga", pdev);\r
1051         if (ret)\r
1052         {\r
1053                 ERR("rga request_irq failed (%d).\n", ret);\r
1054                 goto err_irq;\r
1055         }\r
1056 \r
1057         platform_set_drvdata(pdev, data);\r
1058         rga2_drvdata = data;\r
1059 \r
1060         ret = misc_register(&rga2_dev);\r
1061         if(ret)\r
1062         {\r
1063                 ERR("cannot register miscdev (%d)\n", ret);\r
1064                 goto err_misc_register;\r
1065         }\r
1066 \r
1067         pr_info("Driver loaded succesfully\n");\r
1068 \r
1069         return 0;\r
1070 \r
1071 err_misc_register:\r
1072         free_irq(data->irq, pdev);\r
1073 err_irq:\r
1074         iounmap(data->rga_base);\r
1075 err_ioremap:\r
1076         wake_lock_destroy(&data->wake_lock);\r
1077         //kfree(data);\r
1078 \r
1079         return ret;\r
1080 }\r
1081 \r
1082 static int rga2_drv_remove(struct platform_device *pdev)\r
1083 {\r
1084         struct rga2_drvdata_t *data = platform_get_drvdata(pdev);\r
1085         DBG("%s [%d]\n",__FUNCTION__,__LINE__);\r
1086 \r
1087         wake_lock_destroy(&data->wake_lock);\r
1088         misc_deregister(&(data->miscdev));\r
1089         free_irq(data->irq, &data->miscdev);\r
1090         iounmap((void __iomem *)(data->rga_base));\r
1091 \r
1092         //clk_put(data->pd_rga2);\r
1093     //clk_put(data->rga2);\r
1094         devm_clk_put(&pdev->dev, data->aclk_rga2);\r
1095         devm_clk_put(&pdev->dev, data->hclk_rga2);\r
1096 \r
1097         kfree(data);\r
1098         return 0;\r
1099 }\r
1100 \r
1101 static struct platform_driver rga2_driver = {\r
1102         .probe          = rga2_drv_probe,\r
1103         .remove         = __devexit_p(rga2_drv_remove),\r
1104         .driver         = {\r
1105                 .owner  = THIS_MODULE,\r
1106                 .name   = "rga",\r
1107         },\r
1108 };\r
1109 \r
1110 \r
1111 void rga2_test_0(void);\r
1112 \r
1113 static int __init rga2_init(void)\r
1114 {\r
1115         int ret;\r
1116     uint32_t *buf_p;\r
1117 \r
1118     /* malloc pre scale mid buf mmu table */\r
1119     buf_p = kmalloc(1024*256, GFP_KERNEL);\r
1120     rga2_mmu_buf.buf_virtual = buf_p;\r
1121     rga2_mmu_buf.buf = (uint32_t *)virt_to_phys((void *)((uint32_t)buf_p));\r
1122     rga2_mmu_buf.front = 0;\r
1123     rga2_mmu_buf.back = 64*1024;\r
1124     rga2_mmu_buf.size = 64*1024;\r
1125 \r
1126         if ((ret = platform_driver_register(&rga2_driver)) != 0)\r
1127         {\r
1128         printk(KERN_ERR "Platform device register failed (%d).\n", ret);\r
1129                         return ret;\r
1130         }\r
1131 \r
1132     {\r
1133         rga2_session_global.pid = 0x0000ffff;\r
1134         INIT_LIST_HEAD(&rga2_session_global.waiting);\r
1135         INIT_LIST_HEAD(&rga2_session_global.running);\r
1136         INIT_LIST_HEAD(&rga2_session_global.list_session);\r
1137 \r
1138         INIT_LIST_HEAD(&rga2_service.waiting);\r
1139             INIT_LIST_HEAD(&rga2_service.running);\r
1140             INIT_LIST_HEAD(&rga2_service.done);\r
1141         INIT_LIST_HEAD(&rga2_service.session);\r
1142         init_waitqueue_head(&rga2_session_global.wait);\r
1143         //mutex_lock(&rga_service.lock);\r
1144         list_add_tail(&rga2_session_global.list_session, &rga2_service.session);\r
1145         //mutex_unlock(&rga_service.lock);\r
1146         atomic_set(&rga2_session_global.task_running, 0);\r
1147         atomic_set(&rga2_session_global.num_done, 0);\r
1148     }\r
1149 \r
1150     #if RGA2_TEST_CASE\r
1151     rga2_test_0();\r
1152     #endif\r
1153 \r
1154         INFO("Module initialized.\n");\r
1155 \r
1156         return 0;\r
1157 }\r
1158 \r
1159 static void __exit rga2_exit(void)\r
1160 {\r
1161     rga2_power_off();\r
1162 \r
1163     if (rga2_mmu_buf.buf_virtual)\r
1164         kfree(rga2_mmu_buf.buf_virtual);\r
1165 \r
1166         platform_driver_unregister(&rga2_driver);\r
1167 }\r
1168 \r
1169 \r
1170 #if RGA2_TEST_CASE\r
1171 \r
1172 extern struct fb_info * rk_get_fb(int fb_id);\r
1173 EXPORT_SYMBOL(rk_get_fb);\r
1174 \r
1175 extern void rk_direct_fb_show(struct fb_info * fbi);\r
1176 EXPORT_SYMBOL(rk_direct_fb_show);\r
1177 \r
1178 //unsigned int src_buf[1920*1080];\r
1179 //unsigned int dst_buf[1920*1080];\r
1180 //unsigned int tmp_buf[1920*1080 * 2];\r
1181 \r
1182 void rga2_test_0(void)\r
1183 {\r
1184     struct rga2_req req;\r
1185     rga2_session session;\r
1186     unsigned int *src, *dst;\r
1187     uint32_t i, j;\r
1188     uint8_t *p;\r
1189     uint8_t t;\r
1190     uint32_t *dst0, *dst1, *dst2;\r
1191 \r
1192     struct fb_info *fb;\r
1193 \r
1194     session.pid = current->pid;\r
1195         INIT_LIST_HEAD(&session.waiting);\r
1196         INIT_LIST_HEAD(&session.running);\r
1197         INIT_LIST_HEAD(&session.list_session);\r
1198         init_waitqueue_head(&session.wait);\r
1199         /* no need to protect */\r
1200         list_add_tail(&session.list_session, &rga2_service.session);\r
1201         atomic_set(&session.task_running, 0);\r
1202     atomic_set(&session.num_done, 0);\r
1203         //file->private_data = (void *)session;\r
1204 \r
1205     fb = rk_get_fb(0);\r
1206 \r
1207     memset(&req, 0, sizeof(struct rga2_req));\r
1208     src = kmalloc(800*480*4, GFP_KERNEL);\r
1209     dst = kmalloc(800*480*4, GFP_KERNEL);\r
1210 \r
1211     memset(src, 0x80, 800*480*4);\r
1212 \r
1213     dmac_flush_range(&src, &src[800*480*4]);\r
1214     outer_flush_range(virt_to_phys(&src),virt_to_phys(&src[800*480*4]));\r
1215 \r
1216 \r
1217     #if 0\r
1218     memset(src_buf, 0x80, 800*480*4);\r
1219     memset(dst_buf, 0xcc, 800*480*4);\r
1220 \r
1221     dmac_flush_range(&dst_buf[0], &dst_buf[800*480]);\r
1222     outer_flush_range(virt_to_phys(&dst_buf[0]),virt_to_phys(&dst_buf[800*480]));\r
1223     #endif\r
1224 \r
1225     dst0 = &dst;\r
1226 \r
1227     i = j = 0;\r
1228 \r
1229     printk("\n********************************\n");\r
1230     printk("************ RGA2_TEST ************\n");\r
1231     printk("********************************\n\n");\r
1232 \r
1233     req.src.act_w  = 320;\r
1234     req.src.act_h = 240;\r
1235 \r
1236     req.src.vir_w  = 320;\r
1237     req.src.vir_h = 240;\r
1238     req.src.yrgb_addr = (uint32_t)virt_to_phys(src);\r
1239     req.src.uv_addr = (uint32_t)(req.src.yrgb_addr + 800*480);\r
1240     req.src.v_addr = (uint32_t)virt_to_phys(src);\r
1241     req.src.format = RGA2_FORMAT_RGBA_8888;\r
1242 \r
1243     req.dst.act_w  = 320;\r
1244     req.dst.act_h = 240;\r
1245     req.dst.x_offset = 0;\r
1246     req.dst.y_offset = 0;\r
1247 \r
1248     req.dst.vir_w = 320;\r
1249     req.dst.vir_h = 240;\r
1250 \r
1251     req.dst.yrgb_addr = ((uint32_t)virt_to_phys(dst));\r
1252     req.dst.format = RGA2_FORMAT_RGBA_8888;\r
1253 \r
1254     //dst = dst0;\r
1255 \r
1256     //req.render_mode = color_fill_mode;\r
1257     //req.fg_color = 0x80ffffff;\r
1258 \r
1259     req.rotate_mode = 1;\r
1260     req.scale_bicu_mode = 2;\r
1261 \r
1262     //req.alpha_rop_flag = 0;\r
1263     //req.alpha_rop_mode = 0x19;\r
1264     //req.PD_mode = 3;\r
1265 \r
1266     req.rotate_mode = 0;\r
1267 \r
1268     //req.mmu_info.mmu_flag = 0x21;\r
1269     //req.mmu_info.mmu_en = 1;\r
1270 \r
1271     //printk("src = %.8x\n", req.src.yrgb_addr);\r
1272     //printk("src = %.8x\n", req.src.uv_addr);\r
1273     //printk("dst = %.8x\n", req.dst.yrgb_addr);\r
1274 \r
1275     rga2_blit_sync(&session, &req);\r
1276 \r
1277     #if 0\r
1278     fb->var.bits_per_pixel = 32;\r
1279 \r
1280     fb->var.xres = 1280;\r
1281     fb->var.yres = 800;\r
1282 \r
1283     fb->var.red.length = 8;\r
1284     fb->var.red.offset = 0;\r
1285     fb->var.red.msb_right = 0;\r
1286 \r
1287     fb->var.green.length = 8;\r
1288     fb->var.green.offset = 8;\r
1289     fb->var.green.msb_right = 0;\r
1290 \r
1291     fb->var.blue.length = 8;\r
1292 \r
1293     fb->var.blue.offset = 16;\r
1294     fb->var.blue.msb_right = 0;\r
1295 \r
1296     fb->var.transp.length = 8;\r
1297     fb->var.transp.offset = 24;\r
1298     fb->var.transp.msb_right = 0;\r
1299 \r
1300     fb->var.nonstd &= (~0xff);\r
1301     fb->var.nonstd |= 1;\r
1302 \r
1303     fb->fix.smem_start = virt_to_phys(dst);\r
1304 \r
1305     rk_direct_fb_show(fb);\r
1306     #endif\r
1307 \r
1308     if(src)\r
1309         kfree(src);\r
1310     if(dst)\r
1311         kfree(dst);\r
1312 }\r
1313 \r
1314 #endif\r
1315 module_init(rga2_init);\r
1316 module_exit(rga2_exit);\r
1317 \r
1318 /* Module information */\r
1319 MODULE_AUTHOR("zsq@rock-chips.com");\r
1320 MODULE_DESCRIPTION("Driver for rga device");\r
1321 MODULE_LICENSE("GPL");\r