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