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