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