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