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