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