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