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