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