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