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