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