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